1
|
1 |
|
from threading import RLock |
2
|
1 |
|
import logging |
3
|
1 |
|
from datetime import datetime |
4
|
1 |
|
import collections |
5
|
1 |
|
import shelve |
6
|
1 |
|
try: |
7
|
1 |
|
import cPickle as pickle |
8
|
1 |
|
except: |
9
|
1 |
|
import pickle |
10
|
|
|
|
11
|
1 |
|
from opcua import ua |
12
|
1 |
|
from opcua.server.users import User |
13
|
|
|
|
14
|
|
|
|
15
|
1 |
|
class AttributeValue(object): |
16
|
|
|
|
17
|
1 |
|
def __init__(self, value): |
18
|
1 |
|
self.value = value |
19
|
1 |
|
self.value_callback = None |
20
|
1 |
|
self.datachange_callbacks = {} |
21
|
|
|
|
22
|
1 |
|
def __str__(self): |
23
|
|
|
return "AttributeValue({})".format(self.value) |
24
|
1 |
|
__repr__ = __str__ |
25
|
|
|
|
26
|
|
|
|
27
|
1 |
|
class NodeData(object): |
28
|
|
|
|
29
|
1 |
|
def __init__(self, nodeid): |
30
|
1 |
|
self.nodeid = nodeid |
31
|
1 |
|
self.attributes = {} |
32
|
1 |
|
self.references = [] |
33
|
1 |
|
self.call = None |
34
|
|
|
|
35
|
1 |
|
def __str__(self): |
36
|
|
|
return "NodeData(id:{}, attrs:{}, refs:{})".format(self.nodeid, self.attributes, self.references) |
37
|
1 |
|
__repr__ = __str__ |
38
|
|
|
|
39
|
|
|
|
40
|
1 |
|
class AttributeService(object): |
41
|
|
|
|
42
|
1 |
|
def __init__(self, aspace): |
43
|
1 |
|
self.logger = logging.getLogger(__name__) |
44
|
1 |
|
self._aspace = aspace |
45
|
|
|
|
46
|
1 |
|
def read(self, params): |
47
|
1 |
|
self.logger.debug("read %s", params) |
48
|
1 |
|
res = [] |
49
|
1 |
|
for readvalue in params.NodesToRead: |
50
|
1 |
|
res.append(self._aspace.get_attribute_value(readvalue.NodeId, readvalue.AttributeId)) |
51
|
1 |
|
return res |
52
|
|
|
|
53
|
1 |
|
def write(self, params, user=User.Admin): |
54
|
1 |
|
self.logger.debug("write %s as user %s", params, user) |
55
|
1 |
|
res = [] |
56
|
1 |
|
for writevalue in params.NodesToWrite: |
57
|
1 |
|
if user != User.Admin: |
58
|
1 |
|
if writevalue.AttributeId != ua.AttributeIds.Value: |
59
|
1 |
|
res.append(ua.StatusCode(ua.StatusCodes.BadUserAccessDenied)) |
60
|
1 |
|
continue |
61
|
1 |
|
al = self._aspace.get_attribute_value(writevalue.NodeId, ua.AttributeIds.AccessLevel) |
62
|
1 |
|
ual = self._aspace.get_attribute_value(writevalue.NodeId, ua.AttributeIds.UserAccessLevel) |
63
|
1 |
|
if not ua.test_bit(al.Value.Value, ua.AccessLevel.CurrentWrite) or not ua.test_bit(ual.Value.Value, ua.AccessLevel.CurrentWrite): |
64
|
1 |
|
res.append(ua.StatusCode(ua.StatusCodes.BadUserAccessDenied)) |
65
|
1 |
|
continue |
66
|
1 |
|
res.append(self._aspace.set_attribute_value(writevalue.NodeId, writevalue.AttributeId, writevalue.Value)) |
67
|
1 |
|
return res |
68
|
|
|
|
69
|
|
|
|
70
|
1 |
|
class ViewService(object): |
71
|
|
|
|
72
|
1 |
|
def __init__(self, aspace): |
73
|
1 |
|
self.logger = logging.getLogger(__name__) |
74
|
1 |
|
self._aspace = aspace |
75
|
|
|
|
76
|
1 |
|
def browse(self, params): |
77
|
1 |
|
self.logger.debug("browse %s", params) |
78
|
1 |
|
res = [] |
79
|
1 |
|
for desc in params.NodesToBrowse: |
80
|
1 |
|
res.append(self._browse(desc)) |
81
|
1 |
|
return res |
82
|
|
|
|
83
|
1 |
|
def _browse(self, desc): |
84
|
1 |
|
res = ua.BrowseResult() |
85
|
1 |
|
if desc.NodeId not in self._aspace: |
86
|
1 |
|
res.StatusCode = ua.StatusCode(ua.StatusCodes.BadNodeIdInvalid) |
87
|
1 |
|
return res |
88
|
1 |
|
node = self._aspace[desc.NodeId] |
89
|
1 |
|
for ref in node.references: |
90
|
1 |
|
if not self._is_suitable_ref(desc, ref): |
91
|
1 |
|
continue |
92
|
1 |
|
res.References.append(ref) |
93
|
1 |
|
return res |
94
|
|
|
|
95
|
1 |
|
def _is_suitable_ref(self, desc, ref): |
96
|
1 |
|
if not self._suitable_direction(desc.BrowseDirection, ref.IsForward): |
97
|
1 |
|
self.logger.debug("%s is not suitable due to direction", ref) |
98
|
1 |
|
return False |
99
|
1 |
|
if not self._suitable_reftype(desc.ReferenceTypeId, ref.ReferenceTypeId, desc.IncludeSubtypes): |
100
|
1 |
|
self.logger.debug("%s is not suitable due to type", ref) |
101
|
1 |
|
return False |
102
|
1 |
|
if desc.NodeClassMask and ((desc.NodeClassMask & ref.NodeClass) == 0): |
103
|
1 |
|
self.logger.debug("%s is not suitable due to class", ref) |
104
|
1 |
|
return False |
105
|
1 |
|
self.logger.debug("%s is a suitable ref for desc %s", ref, desc) |
106
|
1 |
|
return True |
107
|
|
|
|
108
|
1 |
|
def _suitable_reftype(self, ref1, ref2, subtypes): |
109
|
|
|
""" |
110
|
|
|
""" |
111
|
1 |
|
if ref1.Identifier == ref2.Identifier: |
112
|
1 |
|
return True |
113
|
|
|
#TODO: Please check the changes here |
114
|
1 |
|
elif not subtypes: |
115
|
1 |
|
return False |
116
|
1 |
|
oktypes = self._get_sub_ref(ref1) |
117
|
1 |
|
return ref2 in oktypes |
118
|
|
|
|
119
|
1 |
|
def _get_sub_ref(self, ref): |
120
|
1 |
|
res = [] |
121
|
1 |
|
nodedata = self._aspace[ref] |
122
|
1 |
|
for ref in nodedata.references: |
123
|
1 |
|
if ref.ReferenceTypeId.Identifier == ua.ObjectIds.HasSubtype and ref.IsForward: |
124
|
1 |
|
res.append(ref.NodeId) |
125
|
1 |
|
res += self._get_sub_ref(ref.NodeId) |
126
|
1 |
|
return res |
127
|
|
|
|
128
|
1 |
|
def _suitable_direction(self, desc, isforward): |
129
|
1 |
|
if desc == ua.BrowseDirection.Both: |
130
|
1 |
|
return True |
131
|
1 |
|
if desc == ua.BrowseDirection.Forward and isforward: |
132
|
1 |
|
return True |
133
|
1 |
|
if desc == ua.BrowseDirection.Inverse and not isforward: |
134
|
1 |
|
return True |
135
|
1 |
|
return False |
136
|
|
|
|
137
|
1 |
|
def translate_browsepaths_to_nodeids(self, browsepaths): |
138
|
1 |
|
self.logger.debug("translate browsepath: %s", browsepaths) |
139
|
1 |
|
results = [] |
140
|
1 |
|
for path in browsepaths: |
141
|
1 |
|
results.append(self._translate_browsepath_to_nodeid(path)) |
142
|
1 |
|
return results |
143
|
|
|
|
144
|
1 |
|
def _translate_browsepath_to_nodeid(self, path): |
145
|
1 |
|
self.logger.debug("looking at path: %s", path) |
146
|
1 |
|
res = ua.BrowsePathResult() |
147
|
1 |
|
if path.StartingNode not in self._aspace: |
148
|
1 |
|
res.StatusCode = ua.StatusCode(ua.StatusCodes.BadNodeIdInvalid) |
149
|
1 |
|
return res |
150
|
1 |
|
current = path.StartingNode |
151
|
1 |
|
for el in path.RelativePath.Elements: |
152
|
1 |
|
nodeid = self._find_element_in_node(el, current) |
153
|
1 |
|
if not nodeid: |
154
|
1 |
|
res.StatusCode = ua.StatusCode(ua.StatusCodes.BadNoMatch) |
155
|
1 |
|
return res |
156
|
1 |
|
current = nodeid |
157
|
1 |
|
target = ua.BrowsePathTarget() |
158
|
1 |
|
target.TargetId = current |
159
|
1 |
|
target.RemainingPathIndex = 4294967295 |
160
|
1 |
|
res.Targets = [target] |
161
|
1 |
|
return res |
162
|
|
|
|
163
|
1 |
|
def _find_element_in_node(self, el, nodeid): |
164
|
1 |
|
nodedata = self._aspace[nodeid] |
165
|
1 |
|
for ref in nodedata.references: |
166
|
|
|
# FIXME: here we should check other arguments!! |
167
|
1 |
|
if ref.BrowseName == el.TargetName: |
168
|
1 |
|
return ref.NodeId |
169
|
1 |
|
self.logger.info("element %s was not found in node %s", el, nodeid) |
170
|
1 |
|
return None |
171
|
|
|
|
172
|
|
|
|
173
|
1 |
|
class NodeManagementService(object): |
174
|
|
|
|
175
|
1 |
|
def __init__(self, aspace): |
176
|
1 |
|
self.logger = logging.getLogger(__name__) |
177
|
1 |
|
self._aspace = aspace |
178
|
|
|
|
179
|
1 |
|
def add_nodes(self, addnodeitems, user=User.Admin): |
180
|
1 |
|
results = [] |
181
|
1 |
|
for item in addnodeitems: |
182
|
1 |
|
results.append(self._add_node(item, user)) |
183
|
1 |
|
return results |
184
|
|
|
|
185
|
1 |
|
def _add_node(self, item, user): |
186
|
1 |
|
result = ua.AddNodesResult() |
187
|
|
|
|
188
|
|
|
# If Identifier of requested NodeId is null we generate a new NodeId using |
189
|
|
|
# the namespace of the nodeid, this is an extention of the spec to allow |
190
|
|
|
# to requests the server to generate a new nodeid in a specified namespace |
191
|
1 |
|
if item.RequestedNewNodeId.has_null_identifier(): |
192
|
1 |
|
self.logger.debug("RequestedNewNodeId has null identifier, generating Identifier") |
193
|
1 |
|
nodedata = NodeData(self._aspace.generate_nodeid(item.RequestedNewNodeId.NamespaceIndex)) |
194
|
|
|
else: |
195
|
1 |
|
nodedata = NodeData(item.RequestedNewNodeId) |
196
|
|
|
|
197
|
1 |
|
if nodedata.nodeid in self._aspace: |
198
|
1 |
|
self.logger.warning("AddNodesItem: node already exists") |
199
|
1 |
|
result.StatusCode = ua.StatusCode(ua.StatusCodes.BadNodeIdExists) |
200
|
1 |
|
return result |
201
|
|
|
|
202
|
1 |
|
if item.ParentNodeId.is_null(): |
203
|
|
|
# self.logger.warning("add_node: creating node %s without parent", nodedata.nodeid) |
204
|
|
|
# We should return Error here, but the standard namespace seems to define many nodes |
205
|
|
|
# without parents, so ignore... |
206
|
1 |
|
pass |
207
|
1 |
|
elif item.ParentNodeId not in self._aspace: |
208
|
1 |
|
self.logger.warning("add_node: while adding node %s, requested parent node %s does not exists", nodedata.nodeid, item.ParentNodeId) |
209
|
1 |
|
result.StatusCode = ua.StatusCode(ua.StatusCodes.BadParentNodeIdInvalid) |
210
|
1 |
|
return result |
211
|
|
|
|
212
|
1 |
|
if not user == User.Admin: |
213
|
1 |
|
result.StatusCode = ua.StatusCode(ua.StatusCodes.BadUserAccessDenied) |
214
|
1 |
|
return result |
215
|
|
|
|
216
|
|
|
# add common attrs |
217
|
1 |
|
nodedata.attributes[ua.AttributeIds.NodeId] = AttributeValue(ua.DataValue(ua.Variant(nodedata.nodeid, ua.VariantType.NodeId))) |
218
|
1 |
|
nodedata.attributes[ua.AttributeIds.BrowseName] = AttributeValue(ua.DataValue(ua.Variant(item.BrowseName, ua.VariantType.QualifiedName))) |
219
|
1 |
|
nodedata.attributes[ua.AttributeIds.NodeClass] = AttributeValue(ua.DataValue(ua.Variant(item.NodeClass, ua.VariantType.Int32))) |
220
|
|
|
# add requested attrs |
221
|
1 |
|
self._add_nodeattributes(item.NodeAttributes, nodedata) |
222
|
|
|
|
223
|
|
|
# now add our node to db |
224
|
1 |
|
self._aspace[nodedata.nodeid] = nodedata |
225
|
|
|
|
226
|
1 |
|
if not item.ParentNodeId.is_null(): |
227
|
1 |
|
self._add_ref_from_parent(nodedata, item) |
228
|
1 |
|
self._add_ref_to_parent(nodedata, item, user) |
229
|
|
|
|
230
|
|
|
# add type definition |
231
|
1 |
|
if item.TypeDefinition != ua.NodeId(): |
232
|
1 |
|
self._add_type_definition(nodedata, item, user) |
233
|
|
|
|
234
|
1 |
|
result.StatusCode = ua.StatusCode() |
235
|
1 |
|
result.AddedNodeId = nodedata.nodeid |
236
|
|
|
|
237
|
1 |
|
return result |
238
|
|
|
|
239
|
1 |
|
def _add_ref_from_parent(self, nodedata, item): |
240
|
1 |
|
desc = ua.ReferenceDescription() |
241
|
1 |
|
desc.ReferenceTypeId = item.ReferenceTypeId |
242
|
1 |
|
desc.NodeId = nodedata.nodeid |
243
|
1 |
|
desc.NodeClass = item.NodeClass |
244
|
1 |
|
desc.BrowseName = item.BrowseName |
245
|
1 |
|
desc.DisplayName = ua.LocalizedText(item.BrowseName.Name) |
246
|
1 |
|
desc.TypeDefinition = item.TypeDefinition |
247
|
1 |
|
desc.IsForward = True |
248
|
1 |
|
self._aspace[item.ParentNodeId].references.append(desc) |
249
|
|
|
|
250
|
1 |
|
def _add_ref_to_parent(self, nodedata, item, user): |
251
|
1 |
|
addref = ua.AddReferencesItem() |
252
|
1 |
|
addref.ReferenceTypeId = item.ReferenceTypeId |
253
|
1 |
|
addref.SourceNodeId = nodedata.nodeid |
254
|
1 |
|
addref.TargetNodeId = item.ParentNodeId |
255
|
1 |
|
addref.TargetNodeClass = self._aspace[item.ParentNodeId].attributes[ua.AttributeIds.NodeClass].value.Value.Value |
256
|
1 |
|
addref.IsForward = False |
257
|
1 |
|
self._add_reference(addref, user) |
258
|
|
|
|
259
|
1 |
|
def _add_type_definition(self, nodedata, item, user): |
260
|
1 |
|
addref = ua.AddReferencesItem() |
261
|
1 |
|
addref.SourceNodeId = nodedata.nodeid |
262
|
1 |
|
addref.IsForward = True |
263
|
1 |
|
addref.ReferenceTypeId = ua.NodeId(ua.ObjectIds.HasTypeDefinition) |
264
|
1 |
|
addref.TargetNodeId = item.TypeDefinition |
265
|
1 |
|
addref.TargetNodeClass = ua.NodeClass.DataType |
266
|
1 |
|
self._add_reference(addref, user) |
267
|
|
|
|
268
|
1 |
|
def delete_nodes(self, deletenodeitems, user=User.Admin): |
269
|
1 |
|
results = [] |
270
|
1 |
|
for item in deletenodeitems: |
271
|
1 |
|
results.append(self._delete_node(item, user)) |
272
|
1 |
|
return results |
273
|
|
|
|
274
|
1 |
|
def _delete_node(self, item, user): |
275
|
1 |
|
if user != User.Admin: |
276
|
|
|
return ua.StatusCode(ua.StatusCodes.BadUserAccessDenied) |
277
|
|
|
|
278
|
1 |
|
if item.NodeId not in self._aspace: |
279
|
|
|
self.logger.warning("DeleteNodesItem: node does not exists") |
280
|
|
|
return ua.StatusCode(ua.StatusCodes.BadNodeIdUnknown) |
281
|
|
|
|
282
|
1 |
|
if item.DeleteTargetReferences: |
283
|
1 |
|
for elem in self._aspace.keys(): |
284
|
1 |
|
for rdesc in self._aspace[elem].references: |
285
|
1 |
|
if rdesc.NodeId == item.NodeId: |
286
|
1 |
|
self._aspace[elem].references.remove(rdesc) |
287
|
|
|
|
288
|
1 |
|
self._delete_node_callbacks(self._aspace[item.NodeId]) |
289
|
|
|
|
290
|
1 |
|
del(self._aspace[item.NodeId]) |
291
|
|
|
|
292
|
1 |
|
return ua.StatusCode() |
293
|
|
|
|
294
|
1 |
|
def _delete_node_callbacks(self, nodedata): |
295
|
1 |
|
if ua.AttributeIds.Value in nodedata.attributes: |
296
|
1 |
|
for handle, callback in nodedata.attributes[ua.AttributeIds.Value].datachange_callbacks.items(): |
297
|
|
|
try: |
298
|
|
|
callback(handle, None, ua.StatusCode(ua.StatusCodes.BadNodeIdUnknown)) |
299
|
|
|
self._aspace.delete_datachange_callback(handle) |
300
|
|
|
except Exception as ex: |
301
|
|
|
self.logger.exception("Error calling delete node callback callback %s, %s, %s", nodedata, ua.AttributeIds.Value, ex) |
302
|
|
|
|
303
|
1 |
|
def add_references(self, refs, user=User.Admin): |
304
|
1 |
|
result = [] |
305
|
1 |
|
for ref in refs: |
306
|
1 |
|
result.append(self._add_reference(ref, user)) |
307
|
1 |
|
return result |
308
|
|
|
|
309
|
1 |
|
def _add_reference(self, addref, user): |
310
|
1 |
|
if addref.SourceNodeId not in self._aspace: |
311
|
|
|
return ua.StatusCode(ua.StatusCodes.BadSourceNodeIdInvalid) |
312
|
1 |
|
if addref.TargetNodeId not in self._aspace: |
313
|
1 |
|
return ua.StatusCode(ua.StatusCodes.BadTargetNodeIdInvalid) |
314
|
1 |
|
if user != User.Admin: |
315
|
|
|
return ua.StatusCode(ua.StatusCodes.BadUserAccessDenied) |
316
|
1 |
|
rdesc = ua.ReferenceDescription() |
317
|
1 |
|
rdesc.ReferenceTypeId = addref.ReferenceTypeId |
318
|
1 |
|
rdesc.IsForward = addref.IsForward |
319
|
1 |
|
rdesc.NodeId = addref.TargetNodeId |
320
|
1 |
|
rdesc.NodeClass = addref.TargetNodeClass |
321
|
1 |
|
bname = self._aspace.get_attribute_value(addref.TargetNodeId, ua.AttributeIds.BrowseName).Value.Value |
322
|
1 |
|
if bname: |
323
|
1 |
|
rdesc.BrowseName = bname |
324
|
1 |
|
dname = self._aspace.get_attribute_value(addref.TargetNodeId, ua.AttributeIds.DisplayName).Value.Value |
325
|
1 |
|
if dname: |
326
|
1 |
|
rdesc.DisplayName = dname |
327
|
1 |
|
self._aspace[addref.SourceNodeId].references.append(rdesc) |
328
|
1 |
|
return ua.StatusCode() |
329
|
|
|
|
330
|
1 |
|
def delete_references(self, refs, user=User.Admin): |
331
|
|
|
result = [] |
332
|
|
|
for ref in refs: |
333
|
|
|
result.append(self._delete_reference(ref, user)) |
334
|
|
|
return result |
335
|
|
|
|
336
|
1 |
|
def _delete_reference(self, item, user): |
337
|
|
|
if item.SourceNodeId not in self._aspace: |
338
|
|
|
return ua.StatusCode(ua.StatusCodes.BadSourceNodeIdInvalid) |
339
|
|
|
if item.TargetNodeId not in self._aspace: |
340
|
|
|
return ua.StatusCode(ua.StatusCodes.BadTargetNodeIdInvalid) |
341
|
|
|
if user != User.Admin: |
342
|
|
|
return ua.StatusCode(ua.StatusCodes.BadUserAccessDenied) |
343
|
|
|
|
344
|
|
|
for rdesc in self._aspace[item.SourceNodeId].references: |
345
|
|
|
if rdesc.NodeId is item.TargetNodeId: |
346
|
|
|
if rdesc.RefrenceTypeId != item.RefrenceTypeId: |
347
|
|
|
return ua.StatusCode(ua.StatusCodes.BadReferenceTypeIdInvalid) |
348
|
|
|
if rdesc.IsForward == item.IsForward or item.DeleteBidirectional: |
349
|
|
|
self._aspace[item.SourceNodeId].references.remove(rdesc) |
350
|
|
|
|
351
|
|
|
for rdesc in self._aspace[item.TargetNodeId].references: |
352
|
|
|
if rdesc.NodeId is item.SourceNodeId: |
353
|
|
|
if rdesc.RefrenceTypeId != item.RefrenceTypeId: |
354
|
|
|
return ua.StatusCode(ua.StatusCodes.BadReferenceTypeIdInvalid) |
355
|
|
|
if rdesc.IsForward == item.IsForward or item.DeleteBidirectional: |
356
|
|
|
self._aspace[item.SourceNodeId].references.remove(rdesc) |
357
|
|
|
|
358
|
|
|
return ua.StatusCode() |
359
|
|
|
|
360
|
1 |
|
def _add_node_attr(self, item, nodedata, name, vtype=None): |
361
|
1 |
|
if item.SpecifiedAttributes & getattr(ua.NodeAttributesMask, name): |
362
|
1 |
|
dv = ua.DataValue(ua.Variant(getattr(item, name), vtype)) |
363
|
1 |
|
dv.ServerTimestamp = datetime.utcnow() |
364
|
1 |
|
dv.SourceTimestamp = datetime.utcnow() |
365
|
1 |
|
nodedata.attributes[getattr(ua.AttributeIds, name)] = AttributeValue(dv) |
366
|
|
|
|
367
|
1 |
|
def _add_nodeattributes(self, item, nodedata): |
368
|
1 |
|
self._add_node_attr(item, nodedata, "AccessLevel", ua.VariantType.Byte) |
369
|
1 |
|
self._add_node_attr(item, nodedata, "ArrayDimensions", ua.VariantType.Int32) |
370
|
1 |
|
self._add_node_attr(item, nodedata, "BrowseName", ua.VariantType.QualifiedName) |
371
|
1 |
|
self._add_node_attr(item, nodedata, "ContainsNoLoops", ua.VariantType.Boolean) |
372
|
1 |
|
self._add_node_attr(item, nodedata, "DataType", ua.VariantType.NodeId) |
373
|
1 |
|
self._add_node_attr(item, nodedata, "Description", ua.VariantType.LocalizedText) |
374
|
1 |
|
self._add_node_attr(item, nodedata, "DisplayName", ua.VariantType.LocalizedText) |
375
|
1 |
|
self._add_node_attr(item, nodedata, "EventNotifier", ua.VariantType.Byte) |
376
|
1 |
|
self._add_node_attr(item, nodedata, "Executable", ua.VariantType.Boolean) |
377
|
1 |
|
self._add_node_attr(item, nodedata, "Historizing", ua.VariantType.Boolean) |
378
|
1 |
|
self._add_node_attr(item, nodedata, "InverseName", ua.VariantType.LocalizedText) |
379
|
1 |
|
self._add_node_attr(item, nodedata, "IsAbstract", ua.VariantType.Boolean) |
380
|
1 |
|
self._add_node_attr(item, nodedata, "MinimumSamplingInterval", ua.VariantType.Double) |
381
|
1 |
|
self._add_node_attr(item, nodedata, "NodeClass", ua.VariantType.UInt32) |
382
|
1 |
|
self._add_node_attr(item, nodedata, "NodeId", ua.VariantType.NodeId) |
383
|
1 |
|
self._add_node_attr(item, nodedata, "Symmetric", ua.VariantType.Boolean) |
384
|
1 |
|
self._add_node_attr(item, nodedata, "UserAccessLevel", ua.VariantType.Byte) |
385
|
1 |
|
self._add_node_attr(item, nodedata, "UserExecutable", ua.VariantType.Byte) |
386
|
1 |
|
self._add_node_attr(item, nodedata, "UserWriteMask", ua.VariantType.Byte) |
387
|
1 |
|
self._add_node_attr(item, nodedata, "ValueRank", ua.VariantType.Int32) |
388
|
1 |
|
self._add_node_attr(item, nodedata, "WriteMask", ua.VariantType.Byte) |
389
|
1 |
|
self._add_node_attr(item, nodedata, "UserWriteMask", ua.VariantType.Byte) |
390
|
1 |
|
self._add_node_attr(item, nodedata, "Value") |
391
|
|
|
|
392
|
|
|
|
393
|
1 |
|
class MethodService(object): |
394
|
|
|
|
395
|
1 |
|
def __init__(self, aspace): |
396
|
1 |
|
self.logger = logging.getLogger(__name__) |
397
|
1 |
|
self._aspace = aspace |
398
|
|
|
|
399
|
1 |
|
def call(self, methods): |
400
|
1 |
|
results = [] |
401
|
1 |
|
for method in methods: |
402
|
1 |
|
results.append(self._call(method)) |
403
|
1 |
|
return results |
404
|
|
|
|
405
|
1 |
|
def _call(self, method): |
406
|
1 |
|
res = ua.CallMethodResult() |
407
|
1 |
|
if method.ObjectId not in self._aspace or method.MethodId not in self._aspace: |
408
|
1 |
|
res.StatusCode = ua.StatusCode(ua.StatusCodes.BadNodeIdInvalid) |
409
|
|
|
else: |
410
|
1 |
|
node = self._aspace[method.MethodId] |
411
|
1 |
|
if node.call is None: |
412
|
|
|
res.StatusCode = ua.StatusCode(ua.StatusCodes.BadNothingToDo) |
413
|
|
|
else: |
414
|
1 |
|
try: |
415
|
1 |
|
res.OutputArguments = node.call(method.ObjectId, *method.InputArguments) |
416
|
1 |
|
for _ in method.InputArguments: |
417
|
1 |
|
res.InputArgumentResults.append(ua.StatusCode()) |
418
|
1 |
|
except Exception: |
419
|
1 |
|
self.logger.exception("Error executing method call %s, an exception was raised: ", method) |
420
|
1 |
|
res.StatusCode = ua.StatusCode(ua.StatusCodes.BadUnexpectedError) |
421
|
1 |
|
return res |
422
|
|
|
|
423
|
|
|
|
424
|
1 |
|
class AddressSpace(object): |
425
|
|
|
|
426
|
|
|
""" |
427
|
|
|
The address space object stores all the nodes og the OPC-UA server |
428
|
|
|
and helper methods. |
429
|
|
|
The methods are threadsafe |
430
|
|
|
""" |
431
|
|
|
|
432
|
1 |
|
def __init__(self): |
433
|
1 |
|
self.logger = logging.getLogger(__name__) |
434
|
1 |
|
self._nodes = {} |
435
|
1 |
|
self._lock = RLock() # FIXME: should use multiple reader, one writter pattern |
436
|
1 |
|
self._datachange_callback_counter = 200 |
437
|
1 |
|
self._handle_to_attribute_map = {} |
438
|
1 |
|
self._default_idx = 2 |
439
|
1 |
|
self._nodeid_counter = 2000 |
440
|
|
|
|
441
|
1 |
|
def __getitem__(self, nodeid): |
442
|
1 |
|
with self._lock: |
443
|
1 |
|
return self._nodes.__getitem__(nodeid) |
444
|
|
|
|
445
|
1 |
|
def __setitem__(self, nodeid, value): |
446
|
1 |
|
with self._lock: |
447
|
1 |
|
return self._nodes.__setitem__(nodeid, value) |
448
|
|
|
|
449
|
1 |
|
def __contains__(self, nodeid): |
450
|
1 |
|
with self._lock: |
451
|
1 |
|
return self._nodes.__contains__(nodeid) |
452
|
|
|
|
453
|
1 |
|
def __delitem__(self, nodeid): |
454
|
1 |
|
with self._lock: |
455
|
1 |
|
self._nodes.__delitem__(nodeid) |
456
|
|
|
|
457
|
1 |
|
def generate_nodeid(self, idx=0): |
458
|
1 |
|
if not idx: |
459
|
1 |
|
idx = self._default_idx |
460
|
1 |
|
self._nodeid_counter += 1 |
461
|
1 |
|
return ua.NodeId(self._nodeid_counter, idx) |
462
|
|
|
|
463
|
1 |
|
def keys(self): |
464
|
1 |
|
with self._lock: |
465
|
1 |
|
return self._nodes.keys() |
466
|
|
|
|
467
|
1 |
|
def dump(self, path): |
468
|
|
|
""" |
469
|
|
|
dump address space as binary to file |
470
|
|
|
""" |
471
|
|
|
s = shelve.open(path, "n", protocol = pickle.HIGHEST_PROTOCOL) |
472
|
|
|
for nodeid in self._nodes.keys(): |
473
|
|
|
s[nodeid.to_string()] = self._nodes[nodeid] |
474
|
|
|
s.close() |
475
|
|
|
|
476
|
1 |
|
def load(self, path): |
477
|
|
|
""" |
478
|
|
|
load address space from file, overwritting everything current address space |
479
|
|
|
""" |
480
|
|
|
class LazyLoadingDict(collections.MutableMapping): |
481
|
|
|
def __init__(self, source): |
482
|
|
|
self.source = source |
483
|
|
|
self.cache = {} |
484
|
|
|
|
485
|
|
|
def __getitem__(self, key): |
486
|
|
|
try: |
487
|
|
|
return self.cache[key] |
488
|
|
|
except KeyError: |
489
|
|
|
node = self.cache[key] = self.source[key.to_string()] |
490
|
|
|
return node |
491
|
|
|
|
492
|
|
|
def __setitem__(self, key, value): |
493
|
|
|
self.cache[key] = value |
494
|
|
|
|
495
|
|
|
def __contains__(self, key): |
496
|
|
|
return key in self.cache or key.to_string() in self.source |
497
|
|
|
|
498
|
|
|
def __delitem__(self, key): |
499
|
|
|
raise NotImplementedError |
500
|
|
|
|
501
|
|
|
def __iter__(self): |
502
|
|
|
raise NotImplementedError |
503
|
|
|
|
504
|
|
|
def __len__(self): |
505
|
|
|
raise NotImplementedError |
506
|
|
|
|
507
|
|
|
self._nodes = LazyLoader(shelve.open(path, "r")) |
508
|
|
|
|
509
|
1 |
|
def get_attribute_value(self, nodeid, attr): |
510
|
1 |
|
with self._lock: |
511
|
1 |
|
self.logger.debug("get attr val: %s %s", nodeid, attr) |
512
|
1 |
|
if nodeid not in self._nodes: |
513
|
1 |
|
dv = ua.DataValue() |
514
|
1 |
|
dv.StatusCode = ua.StatusCode(ua.StatusCodes.BadNodeIdUnknown) |
515
|
1 |
|
return dv |
516
|
1 |
|
node = self._nodes[nodeid] |
517
|
1 |
|
if attr not in node.attributes: |
518
|
1 |
|
dv = ua.DataValue() |
519
|
1 |
|
dv.StatusCode = ua.StatusCode(ua.StatusCodes.BadAttributeIdInvalid) |
520
|
1 |
|
return dv |
521
|
1 |
|
attval = node.attributes[attr] |
522
|
1 |
|
if attval.value_callback: |
523
|
|
|
return attval.value_callback() |
524
|
1 |
|
return attval.value |
525
|
|
|
|
526
|
1 |
|
def set_attribute_value(self, nodeid, attr, value): |
527
|
1 |
|
with self._lock: |
528
|
1 |
|
self.logger.debug("set attr val: %s %s %s", nodeid, attr, value) |
529
|
1 |
|
if nodeid not in self._nodes: |
530
|
1 |
|
return ua.StatusCode(ua.StatusCodes.BadNodeIdUnknown) |
531
|
1 |
|
node = self._nodes[nodeid] |
532
|
1 |
|
if attr not in node.attributes: |
533
|
1 |
|
return ua.StatusCode(ua.StatusCodes.BadAttributeIdInvalid) |
534
|
1 |
|
if not value.SourceTimestamp: |
535
|
1 |
|
value.SourceTimestamp = datetime.utcnow() |
536
|
1 |
|
if not value.ServerTimestamp: |
537
|
1 |
|
value.ServerTimestamp = datetime.utcnow() |
538
|
|
|
|
539
|
1 |
|
attval = node.attributes[attr] |
540
|
1 |
|
old = attval.value |
541
|
1 |
|
attval.value = value |
542
|
1 |
|
cbs = [] |
543
|
1 |
|
if old.Value != value.Value: # only send call callback when a value change has happend |
544
|
1 |
|
cbs = list(attval.datachange_callbacks.items()) |
545
|
|
|
|
546
|
1 |
|
for k, v in cbs: |
547
|
1 |
|
try: |
548
|
1 |
|
v(k, value) |
549
|
|
|
except Exception as ex: |
550
|
|
|
self.logger.exception("Error calling datachange callback %s, %s, %s", k, v, ex) |
551
|
|
|
|
552
|
1 |
|
return ua.StatusCode() |
553
|
|
|
|
554
|
1 |
|
def add_datachange_callback(self, nodeid, attr, callback): |
555
|
1 |
|
with self._lock: |
556
|
1 |
|
self.logger.debug("set attr callback: %s %s %s", nodeid, attr, callback) |
557
|
1 |
|
if nodeid not in self._nodes: |
558
|
|
|
return ua.StatusCode(ua.StatusCodes.BadNodeIdUnknown), 0 |
559
|
1 |
|
node = self._nodes[nodeid] |
560
|
1 |
|
if attr not in node.attributes: |
561
|
1 |
|
return ua.StatusCode(ua.StatusCodes.BadAttributeIdInvalid), 0 |
562
|
1 |
|
attval = node.attributes[attr] |
563
|
1 |
|
self._datachange_callback_counter += 1 |
564
|
1 |
|
handle = self._datachange_callback_counter |
565
|
1 |
|
attval.datachange_callbacks[handle] = callback |
566
|
1 |
|
self._handle_to_attribute_map[handle] = (nodeid, attr) |
567
|
1 |
|
return ua.StatusCode(), handle |
568
|
|
|
|
569
|
1 |
|
def delete_datachange_callback(self, handle): |
570
|
1 |
|
with self._lock: |
571
|
1 |
|
nodeid, attr = self._handle_to_attribute_map.pop(handle) |
572
|
1 |
|
self._nodes[nodeid].attributes[attr].datachange_callbacks.pop(handle) |
573
|
|
|
|
574
|
1 |
|
def add_method_callback(self, methodid, callback): |
575
|
1 |
|
with self._lock: |
576
|
1 |
|
node = self._nodes[methodid] |
577
|
|
|
node.call = callback |
578
|
|
|
|