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)
