Exemple #1
0
    def __init__(self, isession, etype=ObjectIds.BaseEventType, source=ObjectIds.Server):
        self.isession = isession

        if isinstance(etype, Node):
            self.node = etype
        elif isinstance(etype, ua.NodeId):
            self.node = Node(self.isession, etype)
        else:
            self.node = Node(self.isession, ua.NodeId(etype))

        self.set_members_from_node(self.node)
        if isinstance(source, Node):
            self.SourceNode = source.NodeId
        elif isinstance(etype, ua.NodeId):
            self.SourceNode = source.NodeId
        else:
            self.SourceNode = ua.NodeId(source)

        # set some default values for attributes from BaseEventType, thus that all event must have
        self.EventId = uuid.uuid4().bytes
        self.EventType = self.node.nodeid
        self.LocaleTime = datetime.now()
        self.ReceiveTime = datetime.now()
        self.Time = datetime.now()
        self.Message = ua.LocalizedText()
        self.Severity = ua.Variant(1, ua.VariantType.UInt16)
        self.SourceName = "Server"

        # og set some node attributed we also are expected to have
        self.BrowseName = self.node.get_browse_name()
        self.DisplayName = self.node.get_display_name()
        self.NodeId = self.node.nodeid
        self.NodeClass = self.node.get_node_class()
        self.Description = self.node.get_description()
def _instantiate_node(server, parentid, rdesc, nodeid, bname, recursive=True):
    """
    instantiate a node type under parent
    """

    addnode = ua.AddNodesItem()
    addnode.RequestedNewNodeId = nodeid
    addnode.BrowseName = bname
    addnode.ParentNodeId = parentid
    addnode.ReferenceTypeId = rdesc.ReferenceTypeId
    addnode.TypeDefinition = rdesc.TypeDefinition

    node_type = Node(server, rdesc.NodeId)
    if rdesc.NodeClass in (ua.NodeClass.Object, ua.NodeClass.ObjectType):
        addnode.NodeClass = ua.NodeClass.Object
        _read_and_copy_attrs(node_type, ua.ObjectAttributes(), addnode)

    elif rdesc.NodeClass in (ua.NodeClass.Variable, ua.NodeClass.VariableType):
        addnode.NodeClass = ua.NodeClass.Variable
        _read_and_copy_attrs(node_type, ua.VariableAttributes(), addnode)
    elif rdesc.NodeClass in (ua.NodeClass.Method,):
        addnode.NodeClass = ua.NodeClass.Method
        _read_and_copy_attrs(node_type, ua.MethodAttributes(), addnode)
    else:
        print("Instantiate: Node class not supported: ", rdesc.NodeClass)
        return

    res = server.add_nodes([addnode])[0]

    if recursive:
        descs = node_type.get_children_descriptions(includesubtypes=False)
        for c_rdesc in descs:
            _instantiate_node(server, res.AddedNodeId, c_rdesc, nodeid=ua.NodeId(namespaceidx=res.AddedNodeId.NamespaceIndex), bname=c_rdesc.BrowseName)
    return Node(server, res.AddedNodeId)
Exemple #3
0
def instantiate(parent,
                node_type,
                nodeid=None,
                bname=None,
                dname=None,
                idx=0,
                instantiate_optional=True):
    """
    instantiate a node type under a parent node.
    nodeid and browse name of new node can be specified, or just namespace index
    If they exists children of the node type, such as components, variables and
    properties are also instantiated
    """
    rdesc = _rdesc_from_node(parent, node_type)
    rdesc.TypeDefinition = node_type.nodeid

    if nodeid is None:
        nodeid = ua.NodeId(
            namespaceidx=idx
        )  # will trigger automatic node generation in namespace idx
    if bname is None:
        bname = rdesc.BrowseName
    elif isinstance(bname, str):
        bname = ua.QualifiedName.from_string(bname)

    nodeids = _instantiate_node(parent.server,
                                Node(parent.server, rdesc.NodeId),
                                parent.nodeid,
                                rdesc,
                                nodeid,
                                bname,
                                dname=dname,
                                instantiate_optional=instantiate_optional)
    return [Node(parent.server, nid) for nid in nodeids]
Exemple #4
0
    def __init__(self, isession, etype=ua.ObjectIds.BaseEventType, source=ua.ObjectIds.Server):
        self.isession = isession

        if isinstance(etype, Node):
            self.node = etype
        elif isinstance(etype, ua.NodeId):
            self.node = Node(self.isession, etype)
        else:
            self.node = Node(self.isession, ua.NodeId(etype))

        self.set_members_from_node(self.node)
        if isinstance(source, Node):
            self.SourceNode = source.NodeId
        elif isinstance(etype, ua.NodeId):
            self.SourceNode = source.NodeId
        else:
            self.SourceNode = ua.NodeId(source)

        # set some default values for attributes from BaseEventType, thus that all event must have
        self.EventId = uuid.uuid4().bytes
        self.EventType = self.node.nodeid
        self.LocaleTime = datetime.now()
        self.ReceiveTime = datetime.now()
        self.Time = datetime.now()
        self.Message = ua.LocalizedText()
        self.Severity = ua.Variant(1, ua.VariantType.UInt16)
        self.SourceName = "Server"

        # og set some node attributed we also are expected to have
        self.BrowseName = self.node.get_browse_name()
        self.DisplayName = self.node.get_display_name()
        self.NodeId = self.node.nodeid
        self.NodeClass = self.node.get_node_class()
        self.Description = self.node.get_description()
Exemple #5
0
    def subscribe_events(self,
                         sourcenode=ua.ObjectIds.Server,
                         evtypes=ua.ObjectIds.BaseEventType,
                         evfilter=None,
                         queuesize=0):
        """
        Subscribe to events from a node. Default node is Server node.
        In most servers the server node is the only one you can subscribe to.
        if evtypes is not provided, evtype defaults to BaseEventType
        if evtypes is a list or tuple of custom event types, the events will be filtered to the supplied types
        Return a handle which can be used to unsubscribe
        """
        sourcenode = Node(self.server, sourcenode)

        if evfilter is None:
            if not type(evtypes) in (list, tuple):
                evtypes = [evtypes]

            evtypes = [Node(self.server, evtype) for evtype in evtypes]

            evfilter = events.get_filter_from_event_type(evtypes)
        return self._subscribe(sourcenode,
                               ua.AttributeIds.EventNotifier,
                               evfilter,
                               queuesize=queuesize)
    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.endpoints = []
        self._channel_id_counter = 5
        self.allow_remote_admin = True

        self.aspace = AddressSpace()
        self.attribute_service = AttributeService(self.aspace)
        self.view_service = ViewService(self.aspace)
        self.method_service = MethodService(self.aspace)
        self.node_mgt_service = NodeManagementService(self.aspace)
        standard_address_space.fill_address_space(self.node_mgt_service)  # import address space from code generated from xml
        #standard_address_space.fill_address_space_from_disk(self.aspace)  # import address space from save db to disc

        # import address space directly from xml, this has preformance impact so disabled
        #importer = xmlimporter.XmlImporter(self.node_mgt_service)
        #importer.import_xml("/home/olivier/python-opcua/schemas/Opc.Ua.NodeSet2.xml")

        self.loop = utils.ThreadLoop()
        self.subscription_service = SubscriptionService(self.loop, self.aspace)

        # create a session to use on server side
        self.isession = InternalSession(self, self.aspace, self.subscription_service, "Internal", user=User.Admin)
        self.current_time_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_CurrentTime))
        uries = ["http://opcfoundation.org/UA/"]
        ns_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
        ns_node.set_value(uries)
Exemple #7
0
 def createEditor(self, parent, option, idx):
     if idx.column() != 1:
         return None
     item = self.attrs_widget.model.itemFromIndex(idx)
     attr, dv = item.data(Qt.UserRole)
     text = item.text()
     if attr == ua.AttributeIds.NodeId:
         return None
     if dv.Value.VariantType == ua.VariantType.Boolean:
         combo = QComboBox(parent)
         combo.addItem("True")
         combo.addItem("False")
         combo.setCurrentText(text)
         return combo
     elif attr == ua.AttributeIds.NodeClass:
         combo = QComboBox(parent)
         for nclass in ua.NodeClass:
             combo.addItem(nclass.name)
         combo.setCurrentText(text)
         return combo
     elif attr == ua.AttributeIds.DataType:
         nodeid = getattr(ua.ObjectIds, text)
         node = Node(self.attrs_widget.current_node.server, nodeid)
         startnode = Node(self.attrs_widget.current_node.server, ua.ObjectIds.BaseDataType)
         button = GetNodeButton(parent, node, startnode)
         return button
     elif attr in (ua.AttributeIds.AccessLevel,
                   ua.AttributeIds.UserAccessLevel,
                   ua.AttributeIds.WriteMask,
                   ua.AttributeIds.UserWriteMask,
                   ua.AttributeIds.EventNotifier):
         return BitEditor(parent, attr, dv.Value.Value)
     else:
         return QStyledItemDelegate.createEditor(self, parent, option, idx)
Exemple #8
0
 def _get_node(self, nodeid):
     if isinstance(nodeid, ua.NodeId):
         node = Node(self.server, nodeid)
     elif isinstance(nodeid, Node):
         node = nodeid
     else:
         node = Node(self.server, ua.NodeId(nodeid))
     return node
Exemple #9
0
class Event(object):

    """
    Create an event based on an event type. Per default is BaseEventType used.
    arguments are:
        server: The InternalSession object to use for query and event triggering
        source: The emiting source for the node, either an objectId, NodeId or a Node
        etype: The event type, either an objectId, a NodeId or a Node object
    """

    def __init__(self, isession, etype=ua.ObjectIds.BaseEventType, source=ua.ObjectIds.Server):
        self.isession = isession

        if isinstance(etype, Node):
            self.node = etype
        elif isinstance(etype, ua.NodeId):
            self.node = Node(self.isession, etype)
        else:
            self.node = Node(self.isession, ua.NodeId(etype))

        self.set_members_from_node(self.node)
        if isinstance(source, Node):
            self.SourceNode = source.NodeId
        elif isinstance(etype, ua.NodeId):
            self.SourceNode = source.NodeId
        else:
            self.SourceNode = ua.NodeId(source)

        # set some default values for attributes from BaseEventType, thus that all event must have
        self.EventId = uuid.uuid4().bytes
        self.EventType = self.node.nodeid
        self.LocaleTime = datetime.now()
        self.ReceiveTime = datetime.now()
        self.Time = datetime.now()
        self.Message = ua.LocalizedText()
        self.Severity = ua.Variant(1, ua.VariantType.UInt16)
        self.SourceName = "Server"

        # og set some node attributed we also are expected to have
        self.BrowseName = self.node.get_browse_name()
        self.DisplayName = self.node.get_display_name()
        self.NodeId = self.node.nodeid
        self.NodeClass = self.node.get_node_class()
        self.Description = self.node.get_description()

    def __str__(self):
        return "Event(Type:{}, Source:{}, Time:{}, Message: {})".format(self.EventType, self.SourceNode, self.Time, self.Message)
    __repr__ = __str__

    def trigger(self):
        self.isession.subscription_service.trigger_event(self)

    def set_members_from_node(self, node):
        references = node.get_children_descriptions(refs=ua.ObjectIds.HasProperty)
        for desc in references:
            node = Node(self.isession, desc.NodeId)
            setattr(self, desc.BrowseName.Name, node.get_value())
Exemple #10
0
class Event(object):

    """
    Create an event based on an event type. Per default is BaseEventType used.
    arguments are:
        server: The InternalSession object to use for query and event triggering
        source: The emiting source for the node, either an objectId, NodeId or a Node
        etype: The event type, either an objectId, a NodeId or a Node object
    """

    def __init__(self, isession, etype=ObjectIds.BaseEventType, source=ObjectIds.Server):
        self.isession = isession

        if isinstance(etype, Node):
            self.node = etype
        elif isinstance(etype, ua.NodeId):
            self.node = Node(self.isession, etype)
        else:
            self.node = Node(self.isession, ua.NodeId(etype))

        self.set_members_from_node(self.node)
        if isinstance(source, Node):
            self.SourceNode = source.NodeId
        elif isinstance(etype, ua.NodeId):
            self.SourceNode = source.NodeId
        else:
            self.SourceNode = ua.NodeId(source)

        # set some default values for attributes from BaseEventType, thus that all event must have
        self.EventId = uuid.uuid4().bytes
        self.EventType = self.node.nodeid
        self.LocaleTime = datetime.now()
        self.ReceiveTime = datetime.now()
        self.Time = datetime.now()
        self.Message = ua.LocalizedText()
        self.Severity = ua.Variant(1, ua.VariantType.UInt16)
        self.SourceName = "Server"

        # og set some node attributed we also are expected to have
        self.BrowseName = self.node.get_browse_name()
        self.DisplayName = self.node.get_display_name()
        self.NodeId = self.node.nodeid
        self.NodeClass = self.node.get_node_class()
        self.Description = self.node.get_description()

    def __str__(self):
        return "Event(Type:{}, Source:{}, Time:{}, Message: {})".format(self.EventType, self.SourceNode, self.Time, self.Message)
    __repr__ = __str__

    def trigger(self):
        self.isession.subscription_service.trigger_event(self)

    def set_members_from_node(self, node):
        references = node.get_children_descriptions(refs=ua.ObjectIds.HasProperty)
        for desc in references:
            node = Node(self.isession, desc.NodeId)
            setattr(self, desc.BrowseName.Name, node.get_value())
 def start(self):
     self.logger.info("starting internal server")
     self.loop.start()
     Node(self.isession,
          ua.NodeId(ua.ObjectIds.Server_ServerStatus_State)).set_value(0)
     Node(self.isession,
          ua.NodeId(ua.ObjectIds.Server_ServerStatus_StartTime)).set_value(
              datetime.now())
     self._set_current_time()
Exemple #12
0
def _instantiate_node(server, parentid, rdesc, nodeid, bname, recursive=True):
    """
    instantiate a node type under parent
    """
    node_type = Node(server, rdesc.NodeId)
    refs = node_type.get_referenced_nodes(refs=ua.ObjectIds.HasModellingRule)

    # skip optional elements
    if len(refs) == 1 and refs[0].nodeid == ua.NodeId(
            ua.ObjectIds.ModellingRule_Optional):
        return []

    addnode = ua.AddNodesItem()
    addnode.RequestedNewNodeId = nodeid
    addnode.BrowseName = bname
    addnode.ParentNodeId = parentid
    addnode.ReferenceTypeId = rdesc.ReferenceTypeId
    addnode.TypeDefinition = rdesc.TypeDefinition

    if rdesc.NodeClass in (ua.NodeClass.Object, ua.NodeClass.ObjectType):
        addnode.NodeClass = ua.NodeClass.Object
        _read_and_copy_attrs(node_type, ua.ObjectAttributes(), addnode)

    elif rdesc.NodeClass in (ua.NodeClass.Variable, ua.NodeClass.VariableType):
        addnode.NodeClass = ua.NodeClass.Variable
        _read_and_copy_attrs(node_type, ua.VariableAttributes(), addnode)
    elif rdesc.NodeClass in (ua.NodeClass.Method, ):
        addnode.NodeClass = ua.NodeClass.Method
        _read_and_copy_attrs(node_type, ua.MethodAttributes(), addnode)
    else:
        print("Instantiate: Node class not supported: ", rdesc.NodeClass)
        return

    res = 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)
        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):
                    nodeids = _instantiate_node(
                        server,
                        res.AddedNodeId,
                        c_rdesc,
                        nodeid=ua.NodeId(
                            namespaceidx=res.AddedNodeId.NamespaceIndex),
                        bname=c_rdesc.BrowseName)
                    added_nodes.extend(nodeids)

    return added_nodes
Exemple #13
0
def _instantiate_node(server, parentid, rdesc, nodeid, bname, dname=None, recursive=True):
    """
    instantiate a node type under parent
    """
    node_type = Node(server, rdesc.NodeId)
    refs = node_type.get_referenced_nodes(refs=ua.ObjectIds.HasModellingRule)

    # skip optional elements
    if len(refs) == 1 and refs[0].nodeid == ua.NodeId(ua.ObjectIds.ModellingRule_Optional):
        return []

    addnode = ua.AddNodesItem()
    addnode.RequestedNewNodeId = nodeid
    addnode.BrowseName = bname
    addnode.ParentNodeId = parentid
    addnode.ReferenceTypeId = rdesc.ReferenceTypeId
    addnode.TypeDefinition = rdesc.TypeDefinition

    if rdesc.NodeClass in (ua.NodeClass.Object, ua.NodeClass.ObjectType):
        addnode.NodeClass = ua.NodeClass.Object
        _read_and_copy_attrs(node_type, ua.ObjectAttributes(), addnode)

    elif rdesc.NodeClass in (ua.NodeClass.Variable, ua.NodeClass.VariableType):
        addnode.NodeClass = ua.NodeClass.Variable
        _read_and_copy_attrs(node_type, ua.VariableAttributes(), addnode)
    elif rdesc.NodeClass in (ua.NodeClass.Method,):
        addnode.NodeClass = ua.NodeClass.Method
        _read_and_copy_attrs(node_type, ua.MethodAttributes(), addnode)
    else:
        logger.warning("Instantiate: Node class not supported: %s", rdesc.NodeClass)
        return
    if dname is not None:
        addnode.NodeAttributes.DisplayName = dname

    res = 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)
        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):
                    # if root node being instantiated has a String NodeId, create the children with a String NodeId
                    if res.AddedNodeId.NodeIdType is ua.NodeIdType.String:
                        inst_nodeid = res.AddedNodeId.Identifier + "." + c_rdesc.BrowseName.Name
                        nodeids = _instantiate_node(server, res.AddedNodeId, c_rdesc, nodeid=ua.NodeId(identifier=inst_nodeid, namespaceidx=res.AddedNodeId.NamespaceIndex), bname=c_rdesc.BrowseName)
                    else:
                        nodeids = _instantiate_node(server, res.AddedNodeId, c_rdesc, nodeid=ua.NodeId(namespaceidx=res.AddedNodeId.NamespaceIndex), bname=c_rdesc.BrowseName)
                    added_nodes.extend(nodeids)

    return added_nodes
Exemple #14
0
 def __init__(self, server, nodeid, name, parent, server_id, **kwargs):
     OpcNode.__init__(self, server=server, nodeid=nodeid)
     AnyTreeNode.__init__(self, name=name, parent=parent, **kwargs)
     self.namespace_index = self.nodeid.NamespaceIndex
     self.node_class = None
     self.variant_type = None
     self.string_nodeid = self.nodeid.to_string()
     self.node_id = self.nodeid.to_string()
     self.server_id = server_id
     self.web_client_ids = set()
     self.handle = None
Exemple #15
0
 def start(self):
     self.logger.info("starting internal server")
     for edp in self.endpoints:
         self._known_servers[edp.Server.ApplicationUri] = ServerDesc(
             edp.Server)
     self.loop.start()
     Node(self.isession,
          ua.NodeId(ua.ObjectIds.Server_ServerStatus_State)).set_value(0)
     Node(self.isession,
          ua.NodeId(ua.ObjectIds.Server_ServerStatus_StartTime)).set_value(
              datetime.now())
     if not self.disabled_clock:
         self._set_current_time()
Exemple #16
0
def _lsprint_1(node, depth, indent=""):
    if not indent:
        print("{:30} {:25} {:25} {:25}".format("DisplayName", "NodeId", "BrowseName", "Value"))
        print("")

    for desc in node.get_children_descriptions():
        if desc.NodeClass == ua.NodeClass.Variable:
            val = Node(node.server, desc.NodeId).get_value()
            print("{}{:30} {!s:25} {!s:25}, {!s:3}".format(indent, desc.DisplayName.to_string(), desc.NodeId.to_string(), desc.BrowseName.to_string(), val))
        else:
            print("{}{:30} {!s:25} {!s:25}".format(indent, desc.DisplayName.to_string(), desc.NodeId.to_string(), desc.BrowseName.to_string()))
        if depth:
            _lsprint_1(Node(node.server, desc.NodeId), depth - 1, indent + "  ")
Exemple #17
0
def _instanciate_node(server, parentid, rdesc, idx):
    """
    Instanciate a new node under 'parent' using a type
    """

    print("Instanciating: node %s in %s" % (rdesc, parentid))
    addnode = ua.AddNodesItem()
    addnode.RequestedNewNodeId = ua.generate_nodeid(idx)
    addnode.BrowseName = rdesc.BrowseName
    addnode.NodeClass = rdesc.NodeClass
    addnode.ParentNodeId = parentid
    addnode.ReferenceTypeId = ua.TwoByteNodeId(ua.ObjectIds.HasComponent)
    addnode.TypeDefinition = rdesc.TypeDefinition
    print("ADDNODE", addnode)

    node_type = Node(server, rdesc.NodeId)

    if rdesc.NodeClass in (ua.NodeClass.Object, ua.NodeClass.ObjectType):
        print(node_type, " is object")
        _read_and_copy_attrs(node_type, ua.ObjectAttributes(), addnode)
        #_add_object_attrs(addnode, rdesc, node_type)

    elif rdesc.NodeClass in (ua.NodeClass.Variable, ua.NodeClass.VariableType):
        print(node_type, " is variable")
        _read_and_copy_attrs(node_type, ua.VariableAttributes(), addnode)
        #_add_variable_attrs(addnode, rdesc, node_type)

    else:
        print("Node class not supported: ", rdesc.NodeClass)

    print("ADDNODE FINAL ", addnode)
    server.add_nodes([addnode])

    refs = []
    ref = ua.AddReferencesItem()
    ref.IsForward = True
    ref.ReferenceTypeId = addnode.ReferenceTypeId
    ref.SourceNodeId = parentid
    ref.TargetNodeClass = addnode.NodeClass
    ref.TargetNodeId = addnode.RequestedNewNodeId

    refs.append(ref)
    server.add_references(refs)

    descs = node_type.get_children_descriptions(
        includesubtypes=False)  #FIXME: should be false
    print("node is", rdesc.NodeId, node_type, node_type.get_children())
    print("Children are: ", descs)
    for rdesc in descs:
        _instanciate_node(server, addnode.RequestedNewNodeId, rdesc, idx)
    return Node(server, addnode.RequestedNewNodeId)
 def __init__(self, server):
     self.root = Node(server, ObjectIds.RootFolder)
     self.objects = Node(server, ObjectIds.ObjectsFolder)
     self.server = Node(server, ObjectIds.Server)
     self.types = Node(server, ObjectIds.TypesFolder)
     self.base_object_type = Node(server, ObjectIds.BaseObjectType)
     self.base_data_type = Node(server, ObjectIds.BaseDataType)
     self.base_event_type = Node(server, ObjectIds.BaseEventType)
     self.base_variable_type = Node(server, ObjectIds.BaseVariableType)
     self.folder_type = Node(server, ObjectIds.FolderType)
def _instanciate_node(server, parentid, rdesc, idx):
    """
    Instanciate a new node under 'parent' using a type
    """

    print("Instanciating: node %s in %s" % (rdesc, parentid))
    addnode = ua.AddNodesItem()
    addnode.RequestedNewNodeId = ua.generate_nodeid(idx)
    addnode.BrowseName = rdesc.BrowseName
    addnode.NodeClass = rdesc.NodeClass
    addnode.ParentNodeId = parentid
    addnode.ReferenceTypeId = ua.TwoByteNodeId(ua.ObjectIds.HasComponent)
    addnode.TypeDefinition = rdesc.TypeDefinition
    print("ADDNODE", addnode)

    node_type = Node(server, rdesc.NodeId)

    if rdesc.NodeClass in (ua.NodeClass.Object, ua.NodeClass.ObjectType):
        print(node_type, " is object")
        _read_and_copy_attrs(node_type, ua.ObjectAttributes(), addnode)
        #_add_object_attrs(addnode, rdesc, node_type)

    elif rdesc.NodeClass in (ua.NodeClass.Variable, ua.NodeClass.VariableType):
        print(node_type, " is variable")
        _read_and_copy_attrs(node_type, ua.VariableAttributes(), addnode)
        #_add_variable_attrs(addnode, rdesc, node_type)

    else:
        print("Node class not supported: ", rdesc.NodeClass)

    print("ADDNODE FINAL ", addnode)
    server.add_nodes([addnode])

    refs = []
    ref = ua.AddReferencesItem()
    ref.IsForward = True
    ref.ReferenceTypeId = addnode.ReferenceTypeId
    ref.SourceNodeId = parentid
    ref.TargetNodeClass = addnode.NodeClass
    ref.TargetNodeId = addnode.RequestedNewNodeId

    refs.append(ref)
    server.add_references(refs)

    descs = node_type.get_children_descriptions(includesubtypes=False)  # FIXME: should be false
    print("node is", rdesc.NodeId, node_type, node_type.get_children())
    print("Children are: ", descs)
    for rdesc in descs:
        _instanciate_node(server, addnode.RequestedNewNodeId, rdesc, idx)
    return Node(server, addnode.RequestedNewNodeId)
 def __init__(self):
     self.logger = logging.getLogger(__name__)
     self.endpoints = []
     self._channel_id_counter = 5
     self.aspace = AddressSpace()
     self.load_standard_address_space()
     self.loop = ThreadLoop()
     self.submanager = SubscriptionManager(self.loop, self.aspace)
     # create a session to use on server side
     self.isession = InternalSession(self, self.aspace, self.submanager, "Internal") 
     self._timer = None
     self.current_time_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_CurrentTime))
     uries = ["http://opcfoundation.org/UA/"]
     ns_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
     ns_node.set_value(uries)
def _instantiate_node(server, parentid, rdesc, nodeid, bname, recursive=True):
    """
    instantiate a node type under parent
    """
    
    addnode = ua.AddNodesItem()
    addnode.RequestedNewNodeId = nodeid
    addnode.BrowseName = bname
    addnode.ParentNodeId = parentid
    addnode.ReferenceTypeId = rdesc.ReferenceTypeId
    addnode.TypeDefinition = rdesc.TypeDefinition

    node_type = Node(server, rdesc.NodeId)
    
    refs = node_type.get_referenced_nodes(refs=ua.ObjectIds.HasModellingRule)
    # skip optional elements
    if not(len(refs) == 1 and refs[0].nodeid == ua.NodeId(ua.ObjectIds.ModellingRule_Optional) ):
        
        if rdesc.NodeClass in (ua.NodeClass.Object, ua.NodeClass.ObjectType):
            addnode.NodeClass = ua.NodeClass.Object
            _read_and_copy_attrs(node_type, ua.ObjectAttributes(), addnode)

        elif rdesc.NodeClass in (ua.NodeClass.Variable, ua.NodeClass.VariableType):
            addnode.NodeClass = ua.NodeClass.Variable
            _read_and_copy_attrs(node_type, ua.VariableAttributes(), addnode)            
        elif rdesc.NodeClass in (ua.NodeClass.Method,):
            addnode.NodeClass = ua.NodeClass.Method
            _read_and_copy_attrs(node_type, ua.MethodAttributes(), addnode)
        else:
            print("Instantiate: Node class not supported: ", rdesc.NodeClass)
            return
    
        res = server.add_nodes([addnode])[0]
        
        if recursive:
            parents = ua_utils.get_node_supertypes(node_type, includeitself = True)
            node = Node(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):                    
                        _instantiate_node(server, res.AddedNodeId, c_rdesc, nodeid=ua.NodeId(namespaceidx=res.AddedNodeId.NamespaceIndex), bname=c_rdesc.BrowseName)
                    
        return Node(server, res.AddedNodeId)
    
    else:
        return None
Exemple #22
0
    def trigger(self, time_attr=None, message=None):
        """
        Trigger the event. This will send a notification to all subscribed clients
        """
        self.event.EventId = ua.Variant(uuid.uuid4().hex.encode('utf-8'),
                                        ua.VariantType.ByteString)
        if time_attr:
            self.event.Time = time_attr
        else:
            self.event.Time = datetime.utcnow()
        self.event.ReceiveTime = datetime.utcnow()

        self.event.LocalTime = ua.uaprotocol_auto.TimeZoneDataType()
        if sys.version_info.major > 2:
            localtime = time.localtime(self.event.Time.timestamp())
            self.event.LocalTime.Offset = localtime.tm_gmtoff // 60
        else:
            localtime = time.localtime(time.mktime(
                self.event.Time.timetuple()))
            self.event.LocalTime.Offset = -(time.altzone if localtime.tm_isdst
                                            else time.timezone)
        self.event.LocalTime.DaylightSavingInOffset = bool(
            localtime.tm_isdst != -1)

        if message:
            self.event.Message = ua.LocalizedText(message)
        elif not self.event.Message:
            self.event.Message = ua.LocalizedText(
                Node(self.isession,
                     self.event.SourceNode).get_browse_name().Text)

        self.isession.subscription_service.trigger_event(self.event)
Exemple #23
0
    def create_monitored_items(self, monitored_items):
        """
        low level method to have full control over subscription parameters
        Client handle must be unique since it will be used as key for internal registration of data
        """
        params = ua.CreateMonitoredItemsParameters()
        params.SubscriptionId = self.subscription_id
        params.ItemsToCreate = monitored_items
        params.TimestampsToReturn = ua.TimestampsToReturn.Both

        # insert monitored item into map to avoid notification arrive before result return
        # server_handle is left as None in purpose as we don't get it yet.
        with self._lock:
            for mi in monitored_items:
                data = SubscriptionItemData()
                data.client_handle = mi.RequestedParameters.ClientHandle
                data.node = Node(self.server, mi.ItemToMonitor.NodeId)
                data.attribute = mi.ItemToMonitor.AttributeId
                #TODO: Either use the filter from request or from response. Here it uses from request, in modify it uses from response
                data.mfilter = mi.RequestedParameters.Filter
                self._monitoreditems_map[mi.RequestedParameters.ClientHandle] = data
        results = self.server.create_monitored_items(params)
        mids = []
        # process result, add server_handle, or remove it if failed
        with self._lock:
            for idx, result in enumerate(results):
                mi = params.ItemsToCreate[idx]
                if not result.StatusCode.is_good():
                    del self._monitoreditems_map[mi.RequestedParameters.ClientHandle]
                    mids.append(result.StatusCode)
                    continue
                data = self._monitoreditems_map[mi.RequestedParameters.ClientHandle]
                data.server_handle = result.MonitoredItemId
                mids.append(result.MonitoredItemId)
        return mids
 def get_node(self):
     text = self.lineEdit.text()
     if text and text not in ("None", "Null"):
         current = ua.NodeId.from_string(text)
     else:
         current = ua.NodeId() 
     return Node(self.server, current)
Exemple #25
0
 def add_item(self, desc, parent=None, node=None):
     item = [QStandardItem(desc.DisplayName.to_string()), QStandardItem(desc.BrowseName.to_string()), QStandardItem(desc.NodeId.to_string())]
     if desc.NodeClass == ua.NodeClass.Object:
         if desc.TypeDefinition == ua.TwoByteNodeId(ua.ObjectIds.FolderType):
             item[0].setIcon(QIcon(":/folder.svg"))
         else:
             item[0].setIcon(QIcon(":/object.svg"))
     elif desc.NodeClass == ua.NodeClass.Variable:
         if desc.TypeDefinition == ua.TwoByteNodeId(ua.ObjectIds.PropertyType):
             item[0].setIcon(QIcon(":/property.svg"))
         else:
             item[0].setIcon(QIcon(":/variable.svg"))
     elif desc.NodeClass == ua.NodeClass.Method:
         item[0].setIcon(QIcon(":/method.svg"))
     elif desc.NodeClass == ua.NodeClass.ObjectType:
         item[0].setIcon(QIcon(":/object_type.svg"))
     elif desc.NodeClass == ua.NodeClass.VariableType:
         item[0].setIcon(QIcon(":/variable_type.svg"))
     elif desc.NodeClass == ua.NodeClass.DataType:
         item[0].setIcon(QIcon(":/data_type.svg"))
     elif desc.NodeClass == ua.NodeClass.ReferenceType:
         item[0].setIcon(QIcon(":/reference_type.svg"))
     if node:
         item[0].setData(node)
     else:
         parent_node = parent.data()
         item[0].setData(Node(parent_node.server, desc.NodeId))
     if parent:
         return parent.appendRow(item)
     else:
         return self.appendRow(item)
Exemple #26
0
    def _save_structs(self):
        """
        Save struct and delete our design nodes. They will need to be recreated
        """
        struct_node = self.server_mgr.get_node(ua.ObjectIds.Structure)
        structs = []
        to_delete = []
        for node in self.new_nodes:
            # FIXME: we do not support inheritance
            parent = node.get_parent()
            if parent == struct_node:
                bname = node.get_browse_name()
                st = _Struct(bname.Name, "ExtensionObject")
                childs = node.get_children()
                for child in childs:
                    bname = child.get_browse_name()
                    try:
                        dtype = child.get_data_type()
                    except ua.UaError:
                        logger.warning(
                            "could not get data type for node %s, %s, skipping",
                            child, child.get_browse_name())
                        continue
                    dtype_name = Node(node.server, dtype).get_browse_name()
                    st.fields.append([bname.Name, dtype_name.Name])
                    to_delete.append(child)
                structs.append(st)

        if structs:
            self._save_bsd(structs)

        for node in to_delete:
            node.delete()
            if node in self.new_nodes:
                self.new_nodes.remove(node)
Exemple #27
0
    def create_monitored_items(self, monitored_items):
        """
        low level method to have full control over subscription parameters
        Client handle must be unique since it will be used as key for internal registration of data
        """
        params = ua.CreateMonitoredItemsParameters()
        params.SubscriptionId = self.subscription_id
        params.ItemsToCreate = monitored_items
        params.TimestampsToReturn = ua.TimestampsToReturn.Neither
        
        mids = []
        results = self.server.create_monitored_items(params)
        # FIXME: Race condition here
        # We lock as early as possible. But in some situation, a notification may arrives before
        # locking and we will not be able to prosess it. To avoid issues, users should subscribe 
        # to all nodes at once
        with self._lock:  
            for idx, result in enumerate(results):
                mi = params.ItemsToCreate[idx]
                if not result.StatusCode.is_good():
                    mids.append(result.StatusCode)
                    continue
                data = SubscriptionItemData()
                data.client_handle = mi.RequestedParameters.ClientHandle
                data.node = Node(self.server, mi.ItemToMonitor.NodeId)
                data.attribute = mi.ItemToMonitor.AttributeId
                data.server_handle = result.MonitoredItemId
                #data.mfilter = result.FilterResult
                data.mfilter = mi.RequestedParameters.Filter
                self._monitoreditems_map[mi.RequestedParameters.ClientHandle] = data

                mids.append(result.MonitoredItemId)
        return mids
Exemple #28
0
 def subscribe_events(self,
                      sourcenode=ua.ObjectIds.Server,
                      evtype=ua.ObjectIds.BaseEventType,
                      evfilter=None):
     """
     Subscribe to events from a node. Default node is Server node.
     In most servers the server node is the only one you can subscribe to.
     if evfilter is provided, evtype is ignored
     Return a handle which can be used to unsubscribe
     """
     sourcenode = Node(self.server, sourcenode)
     if evfilter is None:
         evfilter = events.get_filter_from_event_type(
             Node(self.server, evtype))
     return self._subscribe(sourcenode, ua.AttributeIds.EventNotifier,
                            evfilter)
Exemple #29
0
 def test_guid_node_id(self):
     """
     Test that a Node can be instantiated with a GUID string and that the NodeId ca be converted to binary.
     """
     node = Node(None, "ns=4;g=35d5f86f-2777-4550-9d48-b098f5ee285c")
     binary_node_id = ua.ua_binary.nodeid_to_binary(node.nodeid)
     assert type(binary_node_id) is bytes
    def __init__(self, isession, etype=None, emitting_node=ua.ObjectIds.Server):
        if not etype:
            etype = event_objects.BaseEvent()

        self.logger = logging.getLogger(__name__)
        self.isession = isession
        self.event = None
        node = None

        if isinstance(etype, event_objects.BaseEvent):
            self.event = etype
        elif isinstance(etype, Node):
            node = etype
        elif isinstance(etype, ua.NodeId):
            node = Node(self.isession, etype)
        else:
            node = Node(self.isession, ua.NodeId(etype))

        if node:
            self.event = events.get_event_obj_from_type_node(node)

        if isinstance(emitting_node, Node):
            pass
        elif isinstance(emitting_node, ua.NodeId):
            emitting_node = Node(isession, emitting_node)
        else:
            emitting_node = Node(isession, ua.NodeId(emitting_node))

        self.event.emitting_node = emitting_node.nodeid

        if not self.event.SourceNode:
            self.event.SourceNode = emitting_node.nodeid
            self.event.SourceName = emitting_node.get_browse_name().Name

        emitting_node.set_event_notifier([ua.EventNotifier.SubscribeToEvents])
        refs = []
        ref = ua.AddReferencesItem()
        ref.IsForward = True
        ref.ReferenceTypeId = ua.NodeId(ua.ObjectIds.GeneratesEvent)
        ref.SourceNodeId = emitting_node.nodeid
        ref.TargetNodeClass = ua.NodeClass.ObjectType
        ref.TargetNodeId = self.event.EventType
        refs.append(ref)
        results = self.isession.add_references(refs)
        # result.StatusCode.check()

        self.emitting_node = emitting_node
Exemple #31
0
def _lsprint_0(node, depth, indent=""):
    if not indent:
        print("{:30} {:25}".format("DisplayName", "NodeId"))
        print("")
    for desc in node.get_children_descriptions():
        print("{}{:30} {:25}".format(indent, desc.DisplayName.to_string(), desc.NodeId.to_string()))
        if depth:
            _lsprint_0(Node(node.server, desc.NodeId), depth - 1, indent + "  ")
Exemple #32
0
 def createEditor(self, parent, option, idx):
     if idx.column() > 1:
         return None
     data_idx = idx.sibling(idx.row(), 0)
     item = self._widget.model.itemFromIndex(data_idx)
     ref = item.data(Qt.UserRole)
     if idx.column() == 1:
         node = Node(self._widget.node.server, ref.NodeId)
         startnode = Node(self._widget.node.server, ua.ObjectIds.RootFolder)
         button = GetNodeTextButton(parent, node, startnode)
         return button
     elif idx.column() == 0:
         node = Node(self._widget.node.server, ref.ReferenceTypeId)
         startnode = Node(self._widget.node.server,
                          ua.ObjectIds.ReferenceTypesFolder)
         button = GetNodeTextButton(parent, node, startnode)
         return button
Exemple #33
0
 def createEditor(self, parent, option, idx):
     if idx.column() != 1:
         return None
     item = self.attrs_widget.model.itemFromIndex(idx)
     data = item.data(Qt.UserRole)
     if not data.is_editable():
         return None
     text = item.text()
     if isinstance(data, (ListData, MemberData)):
         return QStyledItemDelegate.createEditor(self, parent, option, idx)
     elif data.attr == ua.AttributeIds.NodeId:
         return None
     elif data.uatype == ua.VariantType.Boolean:
         combo = QComboBox(parent)
         combo.addItem("True")
         combo.addItem("False")
         combo.setCurrentText(text)
         return combo
     elif data.attr == ua.AttributeIds.NodeClass:
         combo = QComboBox(parent)
         for nclass in ua.NodeClass:
             combo.addItem(nclass.name)
         combo.setCurrentText(text)
         return combo
     elif data.attr == ua.AttributeIds.ValueRank:
         combo = QComboBox(parent)
         for rank in ua.ValueRank:
             combo.addItem(rank.name)
         combo.setCurrentText(text)
         return combo
     elif data.attr == ua.AttributeIds.DataType:
         #nodeid = getattr(ua.ObjectIds, text)
         nodeid = data.value
         node = Node(self.attrs_widget.current_node.server, nodeid)
         startnode = Node(self.attrs_widget.current_node.server,
                          ua.ObjectIds.BaseDataType)
         button = GetNodeButton(parent, node, startnode)
         return button
     elif data.attr in (ua.AttributeIds.AccessLevel,
                        ua.AttributeIds.UserAccessLevel,
                        ua.AttributeIds.WriteMask,
                        ua.AttributeIds.UserWriteMask,
                        ua.AttributeIds.EventNotifier):
         return BitEditor(parent, data.attr, data.value)
     else:
         return QStyledItemDelegate.createEditor(self, parent, option, idx)
Exemple #34
0
    def __init__(self,
                 isession,
                 etype=None,
                 emitting_node=ua.ObjectIds.Server):
        if not etype:
            etype = event_objects.BaseEvent()

        self.logger = logging.getLogger(__name__)
        self.isession = isession
        self.event = None
        node = None

        if isinstance(etype, event_objects.BaseEvent):
            self.event = etype
        elif isinstance(etype, Node):
            node = etype
        elif isinstance(etype, ua.NodeId):
            node = Node(self.isession, etype)
        else:
            node = Node(self.isession, ua.NodeId(etype))

        if node:
            self.event = events.get_event_obj_from_type_node(node)

        if isinstance(emitting_node, Node):
            pass
        elif isinstance(emitting_node, ua.NodeId):
            emitting_node = Node(isession, emitting_node)
        else:
            emitting_node = Node(isession, ua.NodeId(emitting_node))

        self.event.emitting_node = emitting_node.nodeid

        if not self.event.SourceNode:
            self.event.SourceNode = emitting_node.nodeid
            self.event.SourceName = emitting_node.get_browse_name().Name

        emitting_node.set_event_notifier([ua.EventNotifier.SubscribeToEvents])
        refs = []
        ref = ua.AddReferencesItem()
        ref.IsForward = True
        ref.ReferenceTypeId = ua.NodeId(ua.ObjectIds.GeneratesEvent)
        ref.SourceNodeId = emitting_node.nodeid
        ref.TargetNodeClass = ua.NodeClass.ObjectType
        ref.TargetNodeId = self.event.EventType
        refs.append(ref)
        results = self.isession.add_references(refs)
        # result.StatusCode.check()

        self.emitting_node = emitting_node
Exemple #35
0
    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.endpoints = []
        self._channel_id_counter = 5
        self.allow_remote_admin = True

        self.aspace = AddressSpace()
        self.attribute_service = AttributeService(self.aspace)
        self.view_service = ViewService(self.aspace)
        self.method_service = MethodService(self.aspace)
        self.node_mgt_service = NodeManagementService(self.aspace)
        standard_address_space.fill_address_space(self.node_mgt_service)
        #standard_address_space.fill_address_space_from_disk(self.aspace)

        self.loop = utils.ThreadLoop()
        self.subscription_service = SubscriptionService(self.loop, self.aspace)

        # create a session to use on server side
        self.isession = InternalSession(self,
                                        self.aspace,
                                        self.subscription_service,
                                        "Internal",
                                        user=User.Admin)
        self.current_time_node = Node(
            self.isession,
            ua.NodeId(ua.ObjectIds.Server_ServerStatus_CurrentTime))
        uries = ["http://opcfoundation.org/UA/"]
        ns_node = Node(self.isession,
                       ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
        ns_node.set_value(uries)
def _lsprint_1(node, depth, indent=""):
    if not indent:
        print("{0:30} {1:25} {2:25} {3:25}".format("DisplayName", "NodeId",
                                                   "BrowseName", "Value"))
        print("")

    for desc in node.get_children_descriptions():
        if desc.NodeClass == ua.NodeClass.Variable:
            try:
                val = Node(node.server, desc.NodeId).get_value()
            except UaStatusCodeError as err:
                val = "Bad (0x{0:x})".format(err.code)
            print("{0}{1:30} {2!s:25} {3!s:25}, {4!s:3}".format(
                indent, desc.DisplayName.to_string(), desc.NodeId.to_string(),
                desc.BrowseName.to_string(), val))
        else:
            print("{0}{1:30} {2!s:25} {3!s:25}".format(
                indent, desc.DisplayName.to_string(), desc.NodeId.to_string(),
                desc.BrowseName.to_string()))
        if depth:
            _lsprint_1(Node(node.server, desc.NodeId), depth - 1,
                       indent + "  ")
Exemple #37
0
    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.endpoints = []
        self._channel_id_counter = 5

        self.aspace = AddressSpace()
        self.attribute_service = AttributeService(self.aspace)
        self.view_service = ViewService(self.aspace)
        self.method_service = MethodService(self.aspace)
        self.node_mgt_service = NodeManagementService(self.aspace)
        standard_address_space.fill_address_space(self.node_mgt_service)
        #standard_address_space.fill_address_space_from_disk(self.aspace)

        self.loop = utils.ThreadLoop()
        self.subscription_service = SubscriptionService(self.loop, self.aspace)

        # create a session to use on server side
        self.isession = InternalSession(self, self.aspace, self.subscription_service, "Internal", user=User.Admin)
        self.current_time_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_CurrentTime))
        uries = ["http://opcfoundation.org/UA/"]
        ns_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
        ns_node.set_value(uries)
Exemple #38
0
    def _save_structs(self):
        """
        Save struct and delete our design nodes. They will need to be recreated
        """
        struct_node = self.server_mgr.get_node(ua.ObjectIds.Structure)
        dict_name = "TypeDictionary"
        idx = 1
        urn = self.server_mgr.get_namespace_array()[1]
        to_delete = []
        have_structs = False
        to_add = []
        for node in self.new_nodes:
            # FIXME: we do not support inheritance
            parent = node.get_parent()
            if parent == struct_node:
                if not have_structs:
                    dict_builder = self._create_type_dict_node(idx, urn, dict_name)
                    dict_node = self.server_mgr.get_node(dict_builder.dict_id)
                have_structs = True
                bname = node.get_browse_name()
                try:
                    dict_node.get_child(f"{idx}:{bname.Name}")
                    struct = dict_builder.create_data_type(bname.Name, node.nodeid, init=False)
                except ua.UaError:
                    logger.warning("DataType %s has not been initialized, doing it", bname)
                    struct = dict_builder.create_data_type(bname.Name, node.nodeid, init=True)

                childs = node.get_children()
                for child in childs:
                    bname = child.get_browse_name()
                    try:
                        dtype = child.get_data_type()
                    except ua.UaError:
                        logger.warning("could not get data type for node %s, %s, skipping", child, child.get_browse_name())
                        continue
                    array = False
                    if isinstance(child.get_value(), list) or child.get_array_dimensions():
                        array = True

                    dtype_name = Node(node.server, dtype).get_browse_name()
                    struct.add_field(bname.Name, dtype_name.Name, is_array=array)
                    to_delete.append(child)

                to_add.extend([self.server_mgr.get_node(nodeid) for nodeid in struct.node_ids])

        if have_structs:
            dict_builder.set_dict_byte_string()
            self.new_nodes.extend(to_add)

        for node in to_delete:
            self.delete_node(node, False)
Exemple #39
0
 def add_item(self, desc, parent=None, node=None):
     dname = bname = "No Value"
     if desc.DisplayName:
         dname = desc.DisplayName.to_string()
     if desc.BrowseName:
         bname = desc.BrowseName.to_string()
     nodeid = desc.NodeId.to_string()
     item = [
         QStandardItem(dname),
         QStandardItem(bname),
         QStandardItem(nodeid)
     ]
     if desc.NodeClass == ua.NodeClass.Object:
         if desc.TypeDefinition == ua.TwoByteNodeId(
                 ua.ObjectIds.FolderType):
             item[0].setIcon(QIcon("icons/folder.svg"))
         else:
             try:
                 object_type = self.custom_objects[desc.NodeId]
                 icon = get_icon(object_type)
             except KeyError:
                 icon = "icons/object.svg"
             item[0].setIcon(QIcon(icon))
     elif desc.NodeClass == ua.NodeClass.Variable:
         if desc.TypeDefinition == ua.TwoByteNodeId(
                 ua.ObjectIds.PropertyType):
             item[0].setIcon(QIcon("icons/property.svg"))
         else:
             item[0].setIcon(QIcon("icons/variable.svg"))
     elif desc.NodeClass == ua.NodeClass.Method:
         item[0].setIcon(QIcon("icons/method.svg"))
     elif desc.NodeClass == ua.NodeClass.ObjectType:
         item[0].setIcon(QIcon("icons/objecttype.svg"))
     elif desc.NodeClass == ua.NodeClass.VariableType:
         item[0].setIcon(QIcon("icons/variabletype.svg"))
     elif desc.NodeClass == ua.NodeClass.DataType:
         item[0].setIcon(QIcon("icons/datatype.svg"))
     elif desc.NodeClass == ua.NodeClass.ReferenceType:
         item[0].setIcon(QIcon("icons/referencetype.svg"))
     if node:
         item[0].setData(node, Qt.UserRole)
     else:
         parent_node = parent.data(Qt.UserRole)
         item[0].setData(Node(parent_node.server, desc.NodeId), Qt.UserRole)
     if parent:
         return parent.appendRow(item)
     else:
         return self.appendRow(item)
    def __init__(self, isession, etype=None, source=ua.ObjectIds.Server):
        if not etype:
            etype = event_objects.BaseEvent()

        self.logger = logging.getLogger(__name__)
        self.isession = isession
        self.event = None
        node = None

        if isinstance(etype, event_objects.BaseEvent):
            self.event = etype
        elif isinstance(etype, Node):
            node = etype
        elif isinstance(etype, ua.NodeId):
            node = Node(self.isession, etype)
        else:
            node = Node(self.isession, ua.NodeId(etype))

        if node:
            self.event = events.get_event_obj_from_type_node(node)

        if isinstance(source, Node):
            pass
        elif isinstance(source, ua.NodeId):
            source = Node(isession, source)
        else:
            source = Node(isession, ua.NodeId(source))

        if self.event.SourceNode:
            if source.nodeid != self.event.SourceNode:
                self.logger.warning(
                    "Source NodeId: '%s' and event SourceNode: '%s' are not the same. Using '%s' as SourceNode",
                    str(source.nodeid), str(self.event.SourceNode), str(self.event.SourceNode))
                source = Node(self.isession, self.event.SourceNode)

        self.event.SourceNode = source.nodeid
        self.event.SourceName = source.get_browse_name().Name

        source.set_event_notifier([ua.EventNotifier.SubscribeToEvents])
        refs = []
        ref = ua.AddReferencesItem()
        ref.IsForward = True
        ref.ReferenceTypeId = ua.NodeId(ua.ObjectIds.GeneratesEvent)
        ref.SourceNodeId = source.nodeid
        ref.TargetNodeClass = ua.NodeClass.ObjectType
        ref.TargetNodeId = self.event.EventType
        refs.append(ref)
        results = self.isession.add_references(refs)
class InternalServer(object):

    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.endpoints = []
        self._channel_id_counter = 5
        self.allow_remote_admin = True
        self.disabled_clock = False  # for debugging we may want to disable clock that writes too much in log
        self._known_servers = {}  # used if we are a discovery server

        self.aspace = AddressSpace()
        self.attribute_service = AttributeService(self.aspace)
        self.view_service = ViewService(self.aspace)
        self.method_service = MethodService(self.aspace)
        self.node_mgt_service = NodeManagementService(self.aspace)
        # import address space from code generated from xml
        standard_address_space.fill_address_space(self.node_mgt_service)  
        # import address space from save db to disc
        #standard_address_space.fill_address_space_from_disk(self.aspace)  

        # import address space directly from xml, this has preformance impact so disabled
        #importer = xmlimporter.XmlImporter(self.node_mgt_service)
        #importer.import_xml("/home/olivier/python-opcua/schemas/Opc.Ua.NodeSet2.xml")

        self.loop = utils.ThreadLoop()
        self.subscription_service = SubscriptionService(self.loop, self.aspace)

        # create a session to use on server side
        self.isession = InternalSession(self, self.aspace, self.subscription_service, "Internal", user=User.Admin)
        self.current_time_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_CurrentTime))
        uries = ["http://opcfoundation.org/UA/"]
        ns_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
        ns_node.set_value(uries)

    def load_address_space(self, path):
        self.aspace.load(path)

    def dump_address_space(self, path):
        self.aspace.dump(path)

    def start(self):
        self.logger.info("starting internal server")
        self.loop.start()
        Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_State)).set_value(0)
        Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_StartTime)).set_value(datetime.now())
        if not self.disabled_clock:
            self._set_current_time()

    def stop(self):
        self.logger.info("stopping internal server")
        self.loop.stop()

    def _set_current_time(self):
        self.current_time_node.set_value(datetime.now())
        self.loop.call_later(1, self._set_current_time)

    def get_new_channel_id(self):
        self._channel_id_counter += 1
        return self._channel_id_counter

    def add_endpoint(self, endpoint):
        self.endpoints.append(endpoint)

    def get_endpoints(self, params=None, sockname=None):
        self.logger.info("get endpoint")
        if sockname:
            #return to client the ip address it has access to
            edps = []
            for edp in self.endpoints:
                edp1 = copy(edp)
                url = urlparse(edp1.EndpointUrl)
                url = url._replace(netloc=sockname[0] + ":" + str(sockname[1]))
                edp1.EndpointUrl = url.geturl()
                edps.append(edp1)
                return edps
        return self.endpoints[:]

    def find_servers(self, params):
        #FIXME: implement filtering from parmams.uri 
        servers = []
        for edp in self.endpoints:
            servers.append(edp.Server)
        return servers + [desc.Server for desc in self._known_servers.values()]

    def register_server(self, server, conf=None):
        appdesc = ua.ApplicationDescription()
        appdesc.ApplicationUri = server.ServerUri
        appdesc.ProductUri = server.ProductUri
        appdesc.ApplicationName = server.ServerNames[0]  # FIXME: select name from client locale
        appdesc.ApplicationType = server.ServerType
        appdesc.GatewayServerUri = server.GatewayServerUri
        appdesc.DiscoveryUrls = server.DiscoveryUrls  # FIXME: select discovery uri using reachability from client network
        self._known_servers[server.ServerUri] = ServerDesc(appdesc, conf)

    def register_server2(self, params):
        return self.register_server(params.Server, params.DiscoveryConfiguration)

    def create_session(self, name, user=User.Anonymous):
        return InternalSession(self, self.aspace, self.subscription_service, name, user=user)
class InternalServer(object):
    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.endpoints = []
        self._channel_id_counter = 5
        self.aspace = AddressSpace()
        self.load_standard_address_space()
        self.loop = ThreadLoop()
        self.submanager = SubscriptionManager(self.loop, self.aspace)
        # create a session to use on server side
        self.isession = InternalSession(self, self.aspace, self.submanager, "Internal") 
        self._timer = None
        self.current_time_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_CurrentTime))
        uries = ["http://opcfoundation.org/UA/"]
        ns_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
        ns_node.set_value(uries)

    def load_address_space(self, path):
        self.aspace.load(path)

    def dump_address_space(self, path):
        self.aspace.dump(path)

    def load_standard_address_space(self):
        create_standard_address_space_Part3(self.aspace)
        create_standard_address_space_Part4(self.aspace)
        create_standard_address_space_Part5(self.aspace)
        create_standard_address_space_Part8(self.aspace)
        create_standard_address_space_Part9(self.aspace)
        create_standard_address_space_Part10(self.aspace)
        create_standard_address_space_Part11(self.aspace)
        create_standard_address_space_Part13(self.aspace)

    def start(self): 
        self.logger.info("starting internal server")
        self.loop.start()
        Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_State)).set_value(0)
        Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_StartTime)).set_value(datetime.now())
        self._set_current_time()

    def stop(self):
        self.logger.info("stopping internal server")
        self.loop.stop()

    def _set_current_time(self):
        self.current_time_node.set_value(datetime.now())
        self.loop.call_later(1, self._set_current_time)

    def get_new_channel_id(self):
        self._channel_id_counter += 1
        return self._channel_id_counter

    def add_endpoint(self, endpoint):
        self.endpoints.append(endpoint)

    def get_endpoints(self, params=None):
        self.logger.info("get endpoint")
        #FIXME check params
        return self.endpoints[:]
    
    def create_session(self, name):
        return InternalSession(self, self.aspace, self.submanager, name)
Exemple #43
0
class InternalServer(object):

    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.endpoints = []
        self._channel_id_counter = 5

        self.aspace = AddressSpace()
        self.attribute_service = AttributeService(self.aspace)
        self.view_service = ViewService(self.aspace)
        self.method_service = MethodService(self.aspace)
        self.node_mgt_service = NodeManagementService(self.aspace)
        standard_address_space.fill_address_space(self.node_mgt_service)
        #standard_address_space.fill_address_space_from_disk(self.aspace)

        self.loop = utils.ThreadLoop()
        self.subscription_service = SubscriptionService(self.loop, self.aspace)

        # create a session to use on server side
        self.isession = InternalSession(self, self.aspace, self.subscription_service, "Internal", user=User.Admin)
        self.current_time_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_CurrentTime))
        uries = ["http://opcfoundation.org/UA/"]
        ns_node = Node(self.isession, ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
        ns_node.set_value(uries)

    def load_address_space(self, path):
        self.aspace.load(path)

    def dump_address_space(self, path):
        self.aspace.dump(path)

    def start(self):
        self.logger.info("starting internal server")
        self.loop.start()
        Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_State)).set_value(0)
        Node(self.isession, ua.NodeId(ua.ObjectIds.Server_ServerStatus_StartTime)).set_value(datetime.now())
        self._set_current_time()

    def stop(self):
        self.logger.info("stopping internal server")
        self.loop.stop()

    def _set_current_time(self):
        self.current_time_node.set_value(datetime.now())
        self.loop.call_later(1, self._set_current_time)

    def get_new_channel_id(self):
        self._channel_id_counter += 1
        return self._channel_id_counter

    def add_endpoint(self, endpoint):
        self.endpoints.append(endpoint)

    def get_endpoints(self, params=None, sockname=None):
        self.logger.info("get endpoint")
        if sockname:
            #return to client the ip address it has access to
            edps = []
            for edp in self.endpoints:
                edp1 = copy(edp)
                url = urlparse(edp1.EndpointUrl)
                url = url._replace(netloc=sockname[0] + ":" + str(sockname[1]))
                edp1.EndpointUrl = url.geturl()
                edps.append(edp1)
                return edps
        return self.endpoints[:]

    def find_servers(self, params):
        #FIXME: implement correctly
        servers = []
        for edp in self.endpoints:
            servers.append(edp.Server)
        return servers
        

    def create_session(self, name, user=User.Anonymous):
        return InternalSession(self, self.aspace, self.subscription_service, name, user=user)
Exemple #44
0
 def set_members_from_node(self, node):
     references = node.get_children_descriptions(refs=ua.ObjectIds.HasProperty)
     for desc in references:
         node = Node(self.isession, desc.NodeId)
         setattr(self, desc.BrowseName.Name, node.get_value())