Completed
Push — master ( 5f20c9...6b3dc5 )
by Olivier
03:16
created

  B

Complexity

Total Complexity 38

Size/Duplication

Total Lines 154
Duplicated Lines 0 %

Test Coverage

Coverage 75.42%
Metric Value
dl 0
loc 154
ccs 89
cts 118
cp 0.7542
rs 8.3999
wmc 38

21 Methods

Rating   Name   Duplication   Size   Complexity  
A ddressSpace.add_datachange_callback() 0 14 4
A ddressSpace.__init__() 0 8 1
F ddressSpace.set_attribute_value() 0 27 9
A azyLoadingDict.__init__() 0 3 1
A azyLoadingDict.__contains__() 0 2 1
A ddressSpace.dump() 0 8 2
A azyLoadingDict.__setitem__() 0 2 1
A ddressSpace.keys() 0 3 2
A ddressSpace.__setitem__() 0 3 2
A ddressSpace.__getitem__() 0 3 2
A azyLoadingDict.__delitem__() 0 2 1
A ddressSpace.generate_nodeid() 0 5 2
A azyLoadingDict.__getitem__() 0 6 2
A ddressSpace.add_method_callback() 0 4 2
A ddressSpace.__contains__() 0 3 2
A azyLoadingDict.__iter__() 0 2 1
A ddressSpace.delete_datachange_callback() 0 4 2
B ddressSpace.get_attribute_value() 0 16 5
A ddressSpace.__delitem__() 0 3 2
B ddressSpace.load() 0 32 1
A azyLoadingDict.__len__() 0 2 1
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