readability - node.server is in fact an InternalSession instance

opcua/common/copy_node.py

@@ -15,11 +15,11 @@ def copy_node(parent, node, nodeid=None, recursive=True):
 
     if nodeid is None:
         nodeid = ua.NodeId(namespaceidx=node.nodeid.NamespaceIndex)
-    added_nodeids = _copy_node(parent.server, parent.nodeid, rdesc, nodeid, recursive)
-    return [Node(parent.server, nid) for nid in added_nodeids]
+    added_nodeids = _copy_node(parent.session_server, parent.nodeid, rdesc, nodeid, recursive)
+    return [Node(parent.session_server, nid) for nid in added_nodeids]
 
 
-def _copy_node(server, parent_nodeid, rdesc, nodeid, recursive):
+def _copy_node(session_server, parent_nodeid, rdesc, nodeid, recursive):
     addnode = ua.AddNodesItem()
     addnode.RequestedNewNodeId = nodeid
     addnode.BrowseName = rdesc.BrowseName
@@ -28,19 +28,19 @@ def _copy_node(server, parent_nodeid, rdesc, nodeid, recursive):
     addnode.TypeDefinition = rdesc.TypeDefinition
     addnode.NodeClass = rdesc.NodeClass
 
-    node_to_copy = Node(server, rdesc.NodeId)
+    node_to_copy = Node(session_server, rdesc.NodeId)
 
     attrObj = getattr(ua, rdesc.NodeClass.name + "Attributes")
     _read_and_copy_attrs(node_to_copy, attrObj(), addnode)
 
-    res = server.add_nodes([addnode])[0]
+    res = session_server.add_nodes([addnode])[0]
 
     added_nodes = [res.AddedNodeId]
 
     if recursive:
         descs = node_to_copy.get_children_descriptions()
         for desc in descs:
-            nodes = _copy_node(server, res.AddedNodeId, desc, nodeid=ua.NodeId(namespaceidx=desc.NodeId.NamespaceIndex), recursive=True)
+            nodes = _copy_node(session_server, res.AddedNodeId, desc, nodeid=ua.NodeId(namespaceidx=desc.NodeId.NamespaceIndex), recursive=True)
             added_nodes.extend(nodes)
 
     return added_nodes

opcua/common/instantiate.py

@@ -30,18 +30,18 @@ def instantiate(parent, node_type, nodeid=None, bname=None, dname=None, idx=0, i
         bname = ua.QualifiedName.from_string(bname)
 
     nodeids = _instantiate_node(
-        parent.server,
-        Node(parent.server, rdesc.NodeId),
+        parent.session_server,
+        Node(parent.session_server, rdesc.NodeId),
         parent.nodeid,
         rdesc,
         nodeid,
         bname,
         dname=dname,
         instantiate_optional=instantiate_optional)
-    return [Node(parent.server, nid) for nid in nodeids]
+    return [Node(parent.session_server, nid) for nid in nodeids]
 
 
-def _instantiate_node(server,
+def _instantiate_node(session_server,
                       node_type,
                       parentid,
                       rdesc,
@@ -80,19 +80,19 @@ def _instantiate_node(server,
     if dname is not None:
         addnode.NodeAttributes.DisplayName = dname
 
-    res = server.add_nodes([addnode])[0]
+    res = session_server.add_nodes([addnode])[0]
     added_nodes = [res.AddedNodeId]
 
     if recursive:
         parents = ua_utils.get_node_supertypes(node_type, includeitself=True)
-        node = Node(server, res.AddedNodeId)
+        node = Node(session_server, res.AddedNodeId)
         for parent in parents:
             descs = parent.get_children_descriptions(includesubtypes=False)
             for c_rdesc in descs:
                 # skip items that already exists, prefer the 'lowest' one in object hierarchy
                 if not ua_utils.is_child_present(node, c_rdesc.BrowseName):
 
-                    c_node_type = Node(server, c_rdesc.NodeId)
+                    c_node_type = Node(session_server, c_rdesc.NodeId)
                     refs = c_node_type.get_referenced_nodes(refs=ua.ObjectIds.HasModellingRule)
                     if not refs:
                         # spec says to ignore nodes without modelling rules
@@ -107,15 +107,15 @@ def _instantiate_node(server,
                     if res.AddedNodeId.NodeIdType is ua.NodeIdType.String:
                         inst_nodeid = res.AddedNodeId.Identifier + "." + c_rdesc.BrowseName.Name
                         nodeids = _instantiate_node(
-                            server,
+                            session_server,
                             c_node_type,
                             res.AddedNodeId,
                             c_rdesc,
                             nodeid=ua.NodeId(identifier=inst_nodeid, namespaceidx=res.AddedNodeId.NamespaceIndex),
                             bname=c_rdesc.BrowseName)
                     else:
                         nodeids = _instantiate_node(
-                            server,
+                            session_server,
                             c_node_type,
                             res.AddedNodeId,
                             c_rdesc,

opcua/common/manage_nodes.py

@@ -38,7 +38,7 @@ def create_folder(parent, nodeid, bname):
     or namespace index, name
     """
     nodeid, qname = _parse_nodeid_qname(nodeid, bname)
-    return node.Node(parent.server, _create_object(parent.server, parent.nodeid, nodeid, qname, ua.ObjectIds.FolderType))
+    return node.Node(parent.session_server, _create_object(parent.session_server, parent.nodeid, nodeid, qname, ua.ObjectIds.FolderType))
 
 
 def create_object(parent, nodeid, bname, objecttype=None):
@@ -50,12 +50,12 @@ def create_object(parent, nodeid, bname, objecttype=None):
     """
     nodeid, qname = _parse_nodeid_qname(nodeid, bname)
     if objecttype is not None:
-        objecttype = node.Node(parent.server, objecttype)
+        objecttype = node.Node(parent.session_server, objecttype)
         dname = ua.LocalizedText(bname)
         nodes = instantiate(parent, objecttype, nodeid, bname=qname, dname=dname)[0]
         return nodes
     else:
-        return node.Node(parent.server, _create_object(parent.server, parent.nodeid, nodeid, qname, ua.ObjectIds.BaseObjectType))
+        return node.Node(parent.session_server, _create_object(parent.session_server, parent.nodeid, nodeid, qname, ua.ObjectIds.BaseObjectType))
 
 
 def create_property(parent, nodeid, bname, val, varianttype=None, datatype=None):
@@ -70,7 +70,7 @@ def create_property(parent, nodeid, bname, val, varianttype=None, datatype=None)
         datatype = ua.NodeId(datatype, 0)
     if datatype and not isinstance(datatype, ua.NodeId):
         raise RuntimeError("datatype argument must be a nodeid or an int refering to a nodeid")
-    return node.Node(parent.server, _create_variable(parent.server, parent.nodeid, nodeid, qname, var, datatype=datatype, isproperty=True))
+    return node.Node(parent.session_server, _create_variable(parent.session_server, parent.nodeid, nodeid, qname, var, datatype=datatype, isproperty=True))
 
 
 def create_variable(parent, nodeid, bname, val, varianttype=None, datatype=None):
@@ -86,7 +86,7 @@ def create_variable(parent, nodeid, bname, val, varianttype=None, datatype=None)
     if datatype and not isinstance(datatype, ua.NodeId):
         raise RuntimeError("datatype argument must be a nodeid or an int refering to a nodeid")
 
-    return node.Node(parent.server, _create_variable(parent.server, parent.nodeid, nodeid, qname, var, datatype=datatype, isproperty=False))
+    return node.Node(parent.session_server, _create_variable(parent.session_server, parent.nodeid, nodeid, qname, var, datatype=datatype, isproperty=False))
 
 
 def create_variable_type(parent, nodeid, bname, datatype):
@@ -100,7 +100,7 @@ def create_variable_type(parent, nodeid, bname, datatype):
         datatype = ua.NodeId(datatype, 0)
     if datatype and not isinstance(datatype, ua.NodeId):
         raise RuntimeError("Data type argument must be a nodeid or an int refering to a nodeid, received: {}".format(datatype))
-    return node.Node(parent.server, _create_variable_type(parent.server, parent.nodeid, nodeid, qname, datatype))
+    return node.Node(parent.session_server, _create_variable_type(parent.session_server, parent.nodeid, nodeid, qname, datatype))
 
 
 def create_reference_type(parent, nodeid, bname, symmetric=True, inversename=None):
@@ -110,7 +110,7 @@ def create_reference_type(parent, nodeid, bname, symmetric=True, inversename=Non
     or idx and name
     """
     nodeid, qname = _parse_nodeid_qname(nodeid, bname)
-    return node.Node(parent.server, _create_reference_type(parent.server, parent.nodeid, nodeid, qname, symmetric, inversename))
+    return node.Node(parent.session_server, _create_reference_type(parent.session_server, parent.nodeid, nodeid, qname, symmetric, inversename))
 
 
 def create_object_type(parent, nodeid, bname):
@@ -120,7 +120,7 @@ def create_object_type(parent, nodeid, bname):
     or namespace index, name
     """
     nodeid, qname = _parse_nodeid_qname(nodeid, bname)
-    return node.Node(parent.server, _create_object_type(parent.server, parent.nodeid, nodeid, qname))
+    return node.Node(parent.session_server, _create_object_type(parent.session_server, parent.nodeid, nodeid, qname))
 
 
 def create_method(parent, *args):
@@ -142,7 +142,7 @@ def create_method(parent, *args):
         outputs = args[4]
     else:
         outputs = []
-    return node.Node(parent.server, _create_method(parent, nodeid, qname, callback, inputs, outputs))
+    return node.Node(parent.session_server, _create_method(parent, nodeid, qname, callback, inputs, outputs))
 
 
 def _create_object(server, parentnodeid, nodeid, qname, objecttype):
@@ -302,9 +302,9 @@ def create_data_type(parent, nodeid, bname, description=None):
     attrs.UserWriteMask = 0
     attrs.IsAbstract = False  # True mean they cannot be instanciated
     addnode.NodeAttributes = attrs
-    results = parent.server.add_nodes([addnode])
+    results = parent.session_server.add_nodes([addnode])
     results[0].StatusCode.check()
-    return node.Node(parent.server, results[0].AddedNodeId)
+    return node.Node(parent.session_server, results[0].AddedNodeId)
 
 
 def _create_method(parent, nodeid, qname, callback, inputs, outputs):
@@ -323,9 +323,9 @@ def _create_method(parent, nodeid, qname, callback, inputs, outputs):
     attrs.Executable = True
     attrs.UserExecutable = True
     addnode.NodeAttributes = attrs
-    results = parent.server.add_nodes([addnode])
+    results = parent.session_server.add_nodes([addnode])
     results[0].StatusCode.check()
-    method = node.Node(parent.server, results[0].AddedNodeId)
+    method = node.Node(parent.session_server, results[0].AddedNodeId)
     if inputs:
         create_property(method,
                         ua.NodeId(namespaceidx=method.nodeid.NamespaceIndex),
@@ -340,8 +340,8 @@ def _create_method(parent, nodeid, qname, callback, inputs, outputs):
                         [_vtype_to_argument(vtype) for vtype in outputs],
                         varianttype=ua.VariantType.ExtensionObject,
                         datatype=ua.ObjectIds.Argument)
-    if hasattr(parent.server, "add_method_callback"):
-        parent.server.add_method_callback(method.nodeid, callback)
+    if hasattr(parent.session_server, "add_method_callback"):
+        parent.session_server.add_method_callback(method.nodeid, callback)
     return results[0].AddedNodeId
 
 

opcua/common/methods.py

@@ -37,18 +37,18 @@ def call_method_full(parent, methodid, *args):
     elif isinstance(methodid, node.Node):
         methodid = methodid.nodeid
 
-    result = _call_method(parent.server, parent.nodeid, methodid, to_variant(*args))
+    result = _call_method(parent.session_server, parent.nodeid, methodid, to_variant(*args))
     result.OutputArguments = [var.Value for var in result.OutputArguments]
     return result
 
 
-def _call_method(server, parentnodeid, methodid, arguments):
+def _call_method(session_server, parentnodeid, methodid, arguments):
     request = ua.CallMethodRequest()
     request.ObjectId = parentnodeid
     request.MethodId = methodid
     request.InputArguments = arguments
     methodstocall = [request]
-    results = server.call(methodstocall)
+    results = session_server.call(methodstocall)
     res = results[0]
     res.StatusCode.check()
     return res