async def _create_variable(server, parentnodeid, nodeid, qname, var, datatype=None, isproperty=False): addnode = ua.AddNodesItem() addnode.RequestedNewNodeId = nodeid addnode.BrowseName = qname addnode.NodeClass = ua.NodeClass.Variable addnode.ParentNodeId = parentnodeid if isproperty: addnode.ReferenceTypeId = ua.NodeId(ua.ObjectIds.HasProperty) addnode.TypeDefinition = ua.NodeId(ua.ObjectIds.PropertyType) else: addnode.ReferenceTypeId = ua.NodeId(ua.ObjectIds.HasComponent) addnode.TypeDefinition = ua.NodeId(ua.ObjectIds.BaseDataVariableType) attrs = ua.VariableAttributes() attrs.Description = ua.LocalizedText(qname.Name) attrs.DisplayName = ua.LocalizedText(qname.Name) if datatype: attrs.DataType = datatype else: attrs.DataType = _guess_datatype(var) attrs.Value = var if not isinstance(var.Value, (list, tuple)): attrs.ValueRank = ua.ValueRank.Scalar else: if var.Dimensions: attrs.ValueRank = len(var.Dimensions) attrs.ArrayDimensions = var.Dimensions attrs.WriteMask = 0 attrs.UserWriteMask = 0 attrs.Historizing = False attrs.AccessLevel = ua.AccessLevel.CurrentRead.mask attrs.UserAccessLevel = ua.AccessLevel.CurrentRead.mask addnode.NodeAttributes = attrs results = await server.add_nodes([addnode]) results[0].StatusCode.check() return results[0].AddedNodeId
async def add_variable(self, obj): node = self._get_add_node_item(obj) attrs = ua.VariableAttributes() if obj.desc: attrs.Description = ua.LocalizedText(obj.desc) attrs.DisplayName = ua.LocalizedText(obj.displayname) attrs.DataType = obj.datatype if obj.value is not None: attrs.Value = self._add_variable_value(obj, ) if obj.rank: attrs.ValueRank = obj.rank if obj.accesslevel: attrs.AccessLevel = obj.accesslevel if obj.useraccesslevel: attrs.UserAccessLevel = obj.useraccesslevel if obj.minsample: attrs.MinimumSamplingInterval = obj.minsample if obj.dimensions: attrs.ArrayDimensions = obj.dimensions node.NodeAttributes = attrs res = await self._get_server().add_nodes([node]) await self._add_refs(obj) res[0].StatusCode.check() return res[0].AddedNodeId
async def _create_object(server, parentnodeid, nodeid, qname, objecttype): addnode = ua.AddNodesItem() addnode.RequestedNewNodeId = nodeid addnode.BrowseName = qname addnode.ParentNodeId = parentnodeid if await make_node(server, parentnodeid).read_type_definition() == ua.NodeId(ua.ObjectIds.FolderType): addnode.ReferenceTypeId = ua.NodeId(ua.ObjectIds.Organizes) else: addnode.ReferenceTypeId = ua.NodeId(ua.ObjectIds.HasComponent) addnode.NodeClass = ua.NodeClass.Object if isinstance(objecttype, int): addnode.TypeDefinition = ua.NodeId(objecttype) else: addnode.TypeDefinition = objecttype attrs = ua.ObjectAttributes() attrs.EventNotifier = 0 attrs.Description = ua.LocalizedText(qname.Name) attrs.DisplayName = ua.LocalizedText(qname.Name) attrs.WriteMask = 0 attrs.UserWriteMask = 0 addnode.NodeAttributes = attrs results = await server.add_nodes([addnode]) results[0].StatusCode.check() return results[0].AddedNodeId
async def test_xml_ext_obj_array(opc, tmpdir): arg = ua.Argument() arg.DataType = ua.NodeId(ua.ObjectIds.Float) arg.Description = ua.LocalizedText("Nice description") arg.ArrayDimensions = [1, 2, 3] arg.Name = "MyArg" arg2 = ua.Argument() arg2.DataType = ua.NodeId(ua.ObjectIds.Int32) arg2.Description = ua.LocalizedText("Nice description2") arg2.ArrayDimensions = [4, 5, 6] arg2.Name = "MyArg2" args = [arg, arg2] node = await opc.opc.nodes.objects.add_variable(2, "xmlexportobj2", args) node2 = await _test_xml_var_type(opc, tmpdir, node, "ext_obj_array", test_equality=False) read_args = await node2.get_value() for i, arg in enumerate(read_args): assert args[i].Name == read_args[i].Name assert args[i].ArrayDimensions == read_args[i].ArrayDimensions assert args[i].Description == read_args[i].Description assert args[i].DataType == read_args[i].DataType
async def create_session(self): """ send a CreateSessionRequest to server with reasonable parameters. If you want o modify settings look at code of this methods and make your own """ desc = ua.ApplicationDescription() desc.ApplicationUri = self.application_uri desc.ProductUri = self.product_uri desc.ApplicationName = ua.LocalizedText(self.name) desc.ApplicationType = ua.ApplicationType.Client params = ua.CreateSessionParameters() # at least 32 random bytes for server to prove possession of private key (specs part 4, 5.6.2.2) nonce = create_nonce(32) params.ClientNonce = nonce params.ClientCertificate = self.security_policy.host_certificate params.ClientDescription = desc params.EndpointUrl = self.server_url.geturl() params.SessionName = f"{self.description} Session{self._session_counter}" # Requested maximum number of milliseconds that a Session should remain open without activity params.RequestedSessionTimeout = self.session_timeout params.MaxResponseMessageSize = 0 # means no max size response = await self.uaclient.create_session(params) if self.security_policy.host_certificate is None: data = nonce else: data = self.security_policy.host_certificate + nonce self.security_policy.asymmetric_cryptography.verify( data, response.ServerSignature.Signature) self._server_nonce = response.ServerNonce if not self.security_policy.peer_certificate: self.security_policy.peer_certificate = response.ServerCertificate elif self.security_policy.peer_certificate != response.ServerCertificate: raise ua.UaError("Server certificate mismatch") # remember PolicyId's: we will use them in activate_session() ep = Client.find_endpoint(response.ServerEndpoints, self.security_policy.Mode, self.security_policy.URI) self._policy_ids = ep.UserIdentityTokens # Actual maximum number of milliseconds that a Session shall remain open without activity if self.session_timeout != response.RevisedSessionTimeout: _logger.warning( "Requested session timeout to be %dms, got %dms instead", self.secure_channel_timeout, response.RevisedSessionTimeout) self.session_timeout = response.RevisedSessionTimeout self._renew_channel_task = self.loop.create_task( self._renew_channel_loop()) return response
async def test_xml_ext_obj(opc, tmpdir): arg = ua.Argument() arg.DataType = ua.NodeId(ua.ObjectIds.Float) arg.Description = ua.LocalizedText("Nice description") arg.ArrayDimensions = [1, 2, 3] arg.Name = "MyArg" node = await opc.opc.nodes.objects.add_variable(2, "xmlexportobj2", arg) node2 = await _test_xml_var_type(opc, tmpdir, node, "ext_obj", test_equality=False) arg2 = await node2.read_value() assert arg.Name == arg2.Name assert arg.ArrayDimensions == arg2.ArrayDimensions assert arg.Description == arg2.Description assert arg.DataType == arg2.DataType
async def register_server(self, server, discovery_configuration=None): """ register a server to discovery server if discovery_configuration is provided, the newer register_server2 service call is used """ serv = ua.RegisteredServer() serv.ServerUri = server.get_application_uri() serv.ProductUri = server.product_uri serv.DiscoveryUrls = [server.endpoint.geturl()] serv.ServerType = server.application_type serv.ServerNames = [ua.LocalizedText(server.name)] serv.IsOnline = True if discovery_configuration: params = ua.RegisterServer2Parameters() params.Server = serv params.DiscoveryConfiguration = discovery_configuration return await self.uaclient.register_server2(params) return await self.uaclient.register_server(serv)
async def create_object(parent, nodeid, bname, objecttype=None): """ create a child node object arguments are nodeid, browsename, [objecttype] or namespace index, name, [objecttype] if objectype is given (a NodeId) then the type node is instantiated inclusive its child nodes """ nodeid, qname = _parse_nodeid_qname(nodeid, bname) if objecttype is not None: objecttype = make_node(parent.server, objecttype) dname = ua.LocalizedText(qname.Name) nodes = await instantiate(parent, objecttype, nodeid, bname=qname, dname=dname) return nodes[0] else: return make_node( parent.server, await _create_object(parent.server, parent.nodeid, nodeid, qname, ua.ObjectIds.BaseObjectType) )
def _add_variable_value(self, obj): """ Returns the value for a Variable based on the objects value type. """ _logger.debug("Setting value with type %s and value %s", obj.valuetype, obj.value) if obj.valuetype == "ListOfExtensionObject": values = [] for ext in obj.value: extobj = self._make_ext_obj(ext) values.append(extobj) return ua.Variant(values, ua.VariantType.ExtensionObject) elif obj.valuetype == "ListOfGuid": return ua.Variant([uuid.UUID(guid) for guid in obj.value], getattr(ua.VariantType, obj.valuetype[6:])) elif obj.valuetype.startswith("ListOf"): vtype = obj.valuetype[6:] if hasattr(ua.ua_binary.Primitives, vtype): return ua.Variant(obj.value, getattr(ua.VariantType, vtype)) elif vtype == "LocalizedText": return ua.Variant([getattr(ua, vtype)(Text=item["Text"], Locale=item["Locale"]) for item in obj.value]) else: return ua.Variant([getattr(ua, vtype)(v) for v in obj.value]) elif obj.valuetype == "ExtensionObject": extobj = self._make_ext_obj(obj.value) return ua.Variant(extobj, getattr(ua.VariantType, obj.valuetype)) elif obj.valuetype == "Guid": return ua.Variant(uuid.UUID(obj.value), getattr(ua.VariantType, obj.valuetype)) elif obj.valuetype == "LocalizedText": ltext = ua.LocalizedText() for name, val in obj.value: if name == "Text": ltext.Text = val elif name == "Locale": ltext.Locale = val else: _logger.warning( "While parsing localizedText value, unkown element: %s with val: %s", name, val, ) return ua.Variant(ltext, ua.VariantType.LocalizedText) elif obj.valuetype == "NodeId": return ua.Variant(ua.NodeId.from_string(obj.value)) else: return ua.Variant(obj.value, getattr(ua.VariantType, obj.valuetype))
async def test_data_type_dict_add_dictionary(srv): add_dictionary = getattr(srv.dict_builder, '_add_dictionary') dict_name = 'TestDict' dict_node = srv.srv.get_node(await add_dictionary(dict_name)) assert await dict_node.read_browse_name() == ua.QualifiedName( dict_name, srv.idx) assert await dict_node.read_node_class() == ua.NodeClass.Variable assert (await dict_node.get_parent()).nodeid == ua.NodeId( ua.ObjectIds.OPCBinarySchema_TypeSystem, 0) assert ua.NodeId( ua.ObjectIds.HasComponent, 0) == (await dict_node.get_references(refs=ua.ObjectIds.HasComponent ))[0].ReferenceTypeId assert await dict_node.read_type_definition() == ua.NodeId( ua.ObjectIds.DataTypeDictionaryType, 0) assert await dict_node.read_display_name() == ua.LocalizedText(dict_name) assert await dict_node.read_data_type() == ua.NodeId( ua.ObjectIds.ByteString) assert await dict_node.read_value_rank() == -1
async def new_enum( server: Union["Server", "Client"], idx: Union[int, ua.NodeId], name: Union[int, ua.QualifiedName], values: List[str], ) -> Node: edef = ua.EnumDefinition() counter = 0 for val_name in values: field = ua.EnumField() field.DisplayName = ua.LocalizedText(Text=val_name) field.Name = val_name field.Value = counter counter += 1 edef.Fields.append(field) dtype = await server.nodes.enum_data_type.add_data_type(idx, name) await dtype.write_data_type_definition(edef) return dtype
def test_text_with_locale(): t0 = ua.LocalizedText('Root') t1 = ua.LocalizedText('Root', 'de-AT') t2 = ua.LocalizedText('Root', 'de-AT') t3 = ua.LocalizedText('Root', 'de-DE') t4 = ua.LocalizedText(locale='de-DE') t5 = ua.LocalizedText(locale='de-DE') assert t0 != t1 assert t1 == t2 assert t1 != t3 assert t3 != t4 assert t4 == t5 t6 = struct_from_binary(ua.LocalizedText, ua.utils.Buffer(struct_to_binary(t1))) assert t1 == t6
async def _write_state(self, state: State): if not isinstance(state, State): raise ValueError( f"Statemachine: {self._name} -> state: {state} is not a instance of StateMachine.State class" ) await self._current_state_node.write_value( ua.LocalizedText(state.name, self.locale), ua.VariantType.LocalizedText) if state.node: if self._current_state_id_node: await self._current_state_id_node.write_value(state.id) if self._current_state_name_node and state.name: await self._current_state_name_node.write_value( state.name, ua.VariantType.QualifiedName) if self._current_state_number_node and state.number: await self._current_state_number_node.write_value( state.number, ua.VariantType.UInt32) if self._current_state_effective_display_name_node and state.effectivedisplayname: await self._current_state_effective_display_name_node.write_value( state.effectivedisplayname, ua.VariantType.LocalizedText)
def _set_endpoints(self, policy=ua.SecurityPolicy, mode=ua.MessageSecurityMode.None_): idtokens = [] if "Anonymous" in self._policyIDs: idtoken = ua.UserTokenPolicy() idtoken.PolicyId = "anonymous" idtoken.TokenType = ua.UserTokenType.Anonymous idtokens.append(idtoken) if "Basic256Sha256" in self._policyIDs: idtoken = ua.UserTokenPolicy() idtoken.PolicyId = 'certificate_basic256sha256' idtoken.TokenType = ua.UserTokenType.Certificate idtokens.append(idtoken) if "Username" in self._policyIDs: idtoken = ua.UserTokenPolicy() idtoken.PolicyId = "username" idtoken.TokenType = ua.UserTokenType.UserName idtokens.append(idtoken) appdesc = ua.ApplicationDescription() appdesc.ApplicationName = ua.LocalizedText(self.name) appdesc.ApplicationUri = self._application_uri appdesc.ApplicationType = self.application_type appdesc.ProductUri = self.product_uri appdesc.DiscoveryUrls.append(self.endpoint.geturl()) edp = ua.EndpointDescription() edp.EndpointUrl = self.endpoint.geturl() edp.Server = appdesc if self.certificate: edp.ServerCertificate = uacrypto.der_from_x509(self.certificate) edp.SecurityMode = mode edp.SecurityPolicyUri = policy.URI edp.UserIdentityTokens = idtokens edp.TransportProfileUri = "http://opcfoundation.org/UA-Profile/Transport/uatcp-uasc-uabinary" edp.SecurityLevel = 0 self.iserver.add_endpoint(edp)
async def main(): server = Server() await server.init() server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/") # setup our own namespace, not really necessary but should as spec uri = "http://examples.freeopcua.github.io" idx = await server.register_namespace(uri) # populating our address space myobj = await server.nodes.objects.add_object(idx, "MyObject") # Creating a custom event: Approach 1 # The custom event object automatically will have members from its parent (BaseEventType) etype = await server.create_custom_event_type( idx, 'MyFirstEvent', ua.ObjectIds.BaseEventType, [('MyNumericProperty', ua.VariantType.Float), ('MyStringProperty', ua.VariantType.String)]) myevgen = await server.get_event_generator(etype, myobj) # Creating a custom event: Approach 2 custom_etype = await server.nodes.base_event_type.add_object_type( 2, 'MySecondEvent') await custom_etype.add_property(2, 'MyIntProperty', ua.Variant(0, ua.VariantType.Int32)) await custom_etype.add_property(2, 'MyBoolProperty', ua.Variant(True, ua.VariantType.Boolean)) mysecondevgen = await server.get_event_generator(custom_etype, myobj) async with server: count = 0 while True: await asyncio.sleep(1) myevgen.event.Message = ua.LocalizedText("MyFirstEvent %d" % count) myevgen.event.Severity = count myevgen.event.MyNumericProperty = count myevgen.event.MyStringProperty = "Property %d" % count await myevgen.trigger() await mysecondevgen.trigger(message="MySecondEvent %d" % count) count += 1
async def test_xml_method(opc, tmpdir): await opc.opc.register_namespace("foo") await opc.opc.register_namespace("bar") o = await opc.opc.nodes.objects.add_object(2, "xmlexportmethod") m = await o.add_method(2, "callme", func, [ua.VariantType.Double, ua.VariantType.String], [ua.VariantType.Float]) # set an arg dimension to a list to test list export inputs = await m.get_child("InputArguments") val = await inputs.read_value() val[0].ArrayDimensions = [2, 2] desc = "My nce description" val[0].Description = ua.LocalizedText(desc) await inputs.write_value(val) # get all nodes and export nodes = [o, m] nodes.extend(await m.get_children()) tmp_path = tmpdir.join("tmp_test_export.xml").strpath await opc.opc.export_xml(nodes, tmp_path) await opc.opc.delete_nodes(nodes) await opc.opc.import_xml(tmp_path) # now see if our nodes are here val = await inputs.read_value() assert 2 == len(val) assert [2, 2] == val[0].ArrayDimensions assert desc == val[0].Description.Text
async def test_xml_localizedtext_with_locale(opc, tmpdir): o = await opc.opc.nodes.objects.add_variable( 2, "xmlltext", ua.LocalizedText("mytext", "en-US")) await _test_xml_var_type(opc, tmpdir, o, "localized_text")
def string_to_val(string, vtype): """ Convert back a string to a python or python-asyncua object Note: no error checking is done here, supplying null strings could raise exceptions (datetime and guid) """ string = string.strip() if string.startswith("["): string = string[1:-1] var = [] for s in string.split(","): s = s.strip() val = string_to_val(s, vtype) var.append(val) return var if vtype == ua.VariantType.Null: val = None elif vtype == ua.VariantType.Boolean: if string in ("True", "true", "on", "On", "1"): val = True else: val = False elif vtype in (ua.VariantType.SByte, ua.VariantType.Int16, ua.VariantType.Int32, ua.VariantType.Int64): if not string: val = 0 else: val = int(string) elif vtype in (ua.VariantType.Byte, ua.VariantType.UInt16, ua.VariantType.UInt32, ua.VariantType.UInt64): if not string: val = 0 else: val = int(string) elif vtype in (ua.VariantType.Float, ua.VariantType.Double): if not string: val = 0.0 else: val = float(string) elif vtype == ua.VariantType.XmlElement: val = ua.XmlElement(string) elif vtype == ua.VariantType.String: val = string elif vtype == ua.VariantType.ByteString: val = string.encode() elif vtype in (ua.VariantType.NodeId, ua.VariantType.ExpandedNodeId): val = ua.NodeId.from_string(string) elif vtype == ua.VariantType.QualifiedName: val = ua.QualifiedName.from_string(string) elif vtype == ua.VariantType.DateTime: val = parser.parse(string) elif vtype == ua.VariantType.LocalizedText: val = ua.LocalizedText(string) elif vtype == ua.VariantType.StatusCode: val = ua.StatusCode(string) elif vtype == ua.VariantType.Guid: val = uuid.UUID(string) else: # FIXME: Some types are probably missing! raise NotImplementedError return val
async def _create_data_type(self, type_name, nodeid=None, init=True): #name = _to_camel_case(type_name) name = type_name if nodeid is None: # create data type node dt_node = ua.AddNodesItem() dt_node.RequestedNewNodeId = ua.NodeId(0, self._idx) dt_node.BrowseName = ua.QualifiedName(name, self._idx) dt_node.NodeClass = ua.NodeClass.DataType dt_node.ParentNodeId = ua.NodeId(ua.ObjectIds.Structure, 0) dt_node.ReferenceTypeId = ua.NodeId(ua.ObjectIds.HasSubtype, 0) dt_attributes = ua.DataTypeAttributes() dt_attributes.DisplayName = ua.LocalizedText(type_name) dt_node.NodeAttributes = dt_attributes res = await self._session_server.add_nodes([dt_node]) data_type_node_id = res[0].AddedNodeId else: data_type_node_id = nodeid added = [data_type_node_id] if init: # create description node desc_node = ua.AddNodesItem() desc_node.RequestedNewNodeId = ua.NodeId(0, self._idx) desc_node.BrowseName = ua.QualifiedName(name, self._idx) desc_node.NodeClass = ua.NodeClass.Variable desc_node.ParentNodeId = self.dict_id desc_node.ReferenceTypeId = ua.NodeId(ua.ObjectIds.HasComponent, 0) desc_node.TypeDefinition = ua.NodeId( ua.ObjectIds.DataTypeDescriptionType, 0) desc_attributes = ua.VariableAttributes() desc_attributes.DisplayName = ua.LocalizedText(type_name) desc_attributes.DataType = ua.NodeId(ua.ObjectIds.String) desc_attributes.Value = ua.Variant(name, ua.VariantType.String) desc_attributes.ValueRank = -1 desc_node.NodeAttributes = desc_attributes res = await self._session_server.add_nodes([desc_node]) description_node_id = res[0].AddedNodeId added.append(description_node_id) # create object node which the loaded python class should link to obj_node = ua.AddNodesItem() obj_node.RequestedNewNodeId = ua.NodeId(0, self._idx) obj_node.BrowseName = ua.QualifiedName('Default Binary', 0) obj_node.NodeClass = ua.NodeClass.Object obj_node.ParentNodeId = data_type_node_id obj_node.ReferenceTypeId = ua.NodeId(ua.ObjectIds.HasEncoding, 0) obj_node.TypeDefinition = ua.NodeId( ua.ObjectIds.DataTypeEncodingType, 0) obj_attributes = ua.ObjectAttributes() obj_attributes.DisplayName = ua.LocalizedText('Default Binary') obj_attributes.EventNotifier = 0 obj_node.NodeAttributes = obj_attributes res = await self._session_server.add_nodes([obj_node]) bind_obj_node_id = res[0].AddedNodeId added.append(bind_obj_node_id) await self._link_nodes(bind_obj_node_id, data_type_node_id, description_node_id) self._type_dictionary.append_struct(type_name) return StructNode(self, data_type_node_id, type_name, added)
def test_string_to_variant_localized_text(): string = "_This is my nøåæ" obj = ua.LocalizedText(string) string_repr = f"LocalizedText(Locale=None, Text='{string}')" assert obj == string_to_val(string, ua.VariantType.LocalizedText) assert string_repr == val_to_string(obj)
def test_string_to_variant_localized_text(): string = "_This is my nøåæ" obj = ua.LocalizedText(string) assert obj == string_to_val(string, ua.VariantType.LocalizedText) assert string == val_to_string(obj)
# populating our address space myfolder = objects.add_folder(idx, "myEmptyFolder") myobj = objects.add_object(idx, "MyObject") myvar = myobj.add_variable(idx, "MyVariable", 6.7) myvar.set_writable() # Set MyVariable to be writable by clients myarrayvar = myobj.add_variable(idx, "myarrayvar", [6.7, 7.9]) myarrayvar = myobj.add_variable(idx, "myStronglytTypedVariable", ua.Variant([], ua.VariantType.UInt32)) myprop = myobj.add_property(idx, "myproperty", "I am a property") mymethod = myobj.add_method(idx, "mymethod", func, [ua.VariantType.Int64], [ua.VariantType.Boolean]) inargx = ua.Argument() inargx.Name = "x" inargx.DataType = ua.NodeId(ua.ObjectIds.Int64) inargx.ValueRank = -1 inargx.ArrayDimensions = [] inargx.Description = ua.LocalizedText("First number x") inargy = ua.Argument() inargy.Name = "y" inargy.DataType = ua.NodeId(ua.ObjectIds.Int64) inargy.ValueRank = -1 inargy.ArrayDimensions = [] inargy.Description = ua.LocalizedText("Second number y") outarg = ua.Argument() outarg.Name = "Result" outarg.DataType = ua.NodeId(ua.ObjectIds.Int64) outarg.ValueRank = -1 outarg.ArrayDimensions = [] outarg.Description = ua.LocalizedText("Multiplication result") multiply_node = myobj.add_method(idx, "multiply", multiply, [inargx, inargy], [outarg])
def test_text_simple(): t = ua.LocalizedText('Root') b = struct_to_binary(t) buf = ua.utils.Buffer(b) t2 = struct_from_binary(ua.LocalizedText, buf) assert t == t2
async def test_xml_localizedtext_array(opc, tmpdir): o = await opc.opc.nodes.objects.add_variable(2, "xmlltext_array", [ua.LocalizedText("erert"), ua.LocalizedText("erert33")]) await _test_xml_var_type(opc, tmpdir, o, "localized_text_array") await opc.opc.delete_nodes([o])
def enum_to_stringlist(a_enum): items = [] for value in a_enum: items.append(ua.LocalizedText(value.name)) return items
async def test_xml_localizedtext_array_with_locale(opc, tmpdir): o = await opc.opc.nodes.objects.add_variable(2, "xmlltext_array", [ ua.LocalizedText(text="erert", locale="en"), ua.LocalizedText(text="erert33", locale="de") ]) await _test_xml_var_type(opc, tmpdir, o, "localized_text_array")
async def test_data_type_dict_create_data_type(srv): type_name = 'CustomizedStruct2' created_type = await srv.dict_builder.create_data_type(type_name) assert isinstance(created_type, StructNode) # Test data type node type_node = srv.srv.get_node(created_type.data_type) assert await type_node.read_browse_name() == ua.QualifiedName( type_name, srv.idx) assert await type_node.read_node_class() == ua.NodeClass.DataType assert (await type_node.get_parent()).nodeid == ua.NodeId( ua.ObjectIds.Structure, 0) assert ua.NodeId( ua.ObjectIds.HasSubtype, 0) == (await type_node.get_references(refs=ua.ObjectIds.HasSubtype ))[0].ReferenceTypeId assert await type_node.read_display_name() == ua.LocalizedText(type_name) # Test description node n = srv.srv.get_node(srv.dict_builder.dict_id) desc_node = await n.get_child(f"{srv.dict_builder._idx}:{type_name}") assert await desc_node.read_browse_name() == ua.QualifiedName( type_name, srv.idx) assert await desc_node.read_node_class() == ua.NodeClass.Variable assert (await desc_node.get_parent()).nodeid == srv.dict_builder.dict_id assert ua.NodeId( ua.ObjectIds.HasComponent, 0) == (await desc_node.get_references(refs=ua.ObjectIds.HasComponent ))[0].ReferenceTypeId assert await desc_node.read_type_definition() == ua.NodeId( ua.ObjectIds.DataTypeDescriptionType, 0) assert await desc_node.read_display_name() == ua.LocalizedText(type_name) assert await desc_node.read_data_type() == ua.NodeId(ua.ObjectIds.String) assert await desc_node.read_value() == type_name assert await desc_node.read_value_rank() == -1 # Test object node obj_node = (await type_node.get_children(refs=ua.ObjectIds.HasEncoding))[0] assert await obj_node.read_browse_name() == ua.QualifiedName( 'Default Binary', 0) assert await obj_node.read_node_class() == ua.NodeClass.Object assert (await obj_node.get_references(refs=ua.ObjectIds.HasEncoding ))[0].NodeId == type_node.nodeid assert ua.NodeId( ua.ObjectIds.HasEncoding, 0) == (await obj_node.get_references(refs=ua.ObjectIds.HasEncoding ))[0].ReferenceTypeId assert await obj_node.read_type_definition() == ua.NodeId( ua.ObjectIds.DataTypeEncodingType, 0) assert await obj_node.read_display_name() == ua.LocalizedText( 'Default Binary') assert len(await obj_node.read_event_notifier()) == 0 # Test links, three were tested above struct_node = srv.srv.get_node(ua.NodeId(ua.ObjectIds.Structure, 0)) struct_children = await struct_node.get_children( refs=ua.ObjectIds.HasSubtype) assert type_node in struct_children dict_node = srv.srv.get_node(srv.dict_builder.dict_id) dict_children = await dict_node.get_children(refs=ua.ObjectIds.HasComponent ) assert desc_node in dict_children assert obj_node in await type_node.get_children(ua.ObjectIds.HasEncoding) assert desc_node in await obj_node.get_children( refs=ua.ObjectIds.HasDescription) assert obj_node.nodeid == (await desc_node.get_references( refs=ua.ObjectIds.HasDescription, direction=ua.BrowseDirection.Inverse))[0].NodeId
async def test_xml_localizedtext(opc, tmpdir): o = await opc.opc.nodes.objects.add_variable(2, "xmlltext", ua.LocalizedText("mytext")) await _test_xml_var_type(opc, tmpdir, o, "localized_text") await opc.opc.delete_nodes([o])
async def test_root(opc): root = opc.opc.get_root_node() assert ua.QualifiedName('Root', 0) == await root.get_browse_name() assert ua.LocalizedText('Root') == await root.get_display_name() nid = ua.NodeId(84, 0) assert nid == root.nodeid
async def main(): # optional: setup logging logging.basicConfig(level=logging.WARN) # logger = logging.getLogger("asyncua.address_space") # logger.setLevel(logging.DEBUG) # logger = logging.getLogger("asyncua.internal_server") # logger.setLevel(logging.DEBUG) # logger = logging.getLogger("asyncua.binary_server_asyncio") # logger.setLevel(logging.DEBUG) # logger = logging.getLogger("asyncua.uaprocessor") # logger.setLevel(logging.DEBUG) # logger = logging.getLogger("asyncua.subscription_service") # logger.setLevel(logging.DEBUG) # now setup our server server = Server() await server.init() # server.set_endpoint("opc.tcp://localhost:4840/freeopcua/server/") server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/") server.set_server_name("FreeOpcUa Example Server") # setup our own namespace uri = "http://examples.freeopcua.github.io" idx = await server.register_namespace(uri) # get Objects node, this is where we should put our custom stuff objects = server.get_objects_node() # populating our address space await objects.add_folder(idx, "myEmptyFolder") myobj = await objects.add_object(idx, "MyObject") myvar = await myobj.add_variable(idx, "MyVariable", 6.7) await myvar.set_writable() # Set MyVariable to be writable by clients myarrayvar = await myobj.add_variable(idx, "myarrayvar", [6.7, 7.9]) await myobj.add_variable(idx, "myStronglytTypedVariable", ua.Variant([], ua.VariantType.UInt32)) await myobj.add_property(idx, "myproperty", "I am a property") await myobj.add_method(idx, "mymethod", func, [ua.VariantType.Int64], [ua.VariantType.Boolean]) inargx = ua.Argument() inargx.Name = "x" inargx.DataType = ua.NodeId(ua.ObjectIds.Int64) inargx.ValueRank = -1 inargx.ArrayDimensions = [] inargx.Description = ua.LocalizedText("First number x") inargy = ua.Argument() inargy.Name = "y" inargy.DataType = ua.NodeId(ua.ObjectIds.Int64) inargy.ValueRank = -1 inargy.ArrayDimensions = [] inargy.Description = ua.LocalizedText("Second number y") outarg = ua.Argument() outarg.Name = "Result" outarg.DataType = ua.NodeId(ua.ObjectIds.Int64) outarg.ValueRank = -1 outarg.ArrayDimensions = [] outarg.Description = ua.LocalizedText("Multiplication result") await myobj.add_method(idx, "multiply", multiply, [inargx, inargy], [outarg]) await myobj.add_method(idx, "multiply_async", multiply_async, [inargx, inargy], []) await myobj.add_method(idx, "func_async", func_async, [ua.VariantType.Int64], []) async with server: while True: await asyncio.sleep(1)