How to prevent an out of range value to be written?

[FMeinicke]

Hi,

I'm currently implementing an OPC UA server using asyncua.
As part of some configuration process, a client might need to write a value to a certain node (data type Double). However, the value can only be in a certain range (let's say 0-100 for simplicity). By default, there is nothing that prevents a client from writing the value 101. The OPC UA specification states that it should be possible for a server to return the status code Bad_OutOfRange in case a client attempts to write a value which is outside of the valid range (https://reference.opcfoundation.org/Core/Part4/v105/docs/5.10.4.4).
I would like to implement this behavior in my server but I'm unsure about the correct way to do so (and if this is even possible with asyncua at all).

I tried to use a subscription handler with a datachange_notification first but discovered that this function is called after the value has already been written to the node.

Then I tried to use a callback function and register it using server.subscribe_server_callback(CallbackType.PreWrite, callback) in order to intercept the value coming from the client before it was written to the node. This does work (i.e. the callback is called before the actual write happens), but as I see it, there is no possibility to "return early" from the whole write process.

After some digging in the internals of asyncua I came up with the idea to replace the Server.iserver.attribute_service with a custom instance of AttributeService which overrides the write method:

from asyncua.server.address_space import AttributeService

class CustomAttributeService(AttributeService):
    async def write(self, params: ua.WriteParameters, user: User = User(role=UserRole.Admin)) -> List[ua.StatusCode]:
        res: List[ua.StatusCode] = []
        for writevalue in params.NodesToWrite:
            ... # code copied from AttributeService.write

            # --- Custom code
            if writevalue.NodeId == ua.NodeId(...):  # the node I'm interested in
                if writevalue.Value.Value.Value > 100:
                    _logger.error(f"Value out of range")
                    res.append(ua.StatusCode(ua.StatusCodes.BadOutOfRange))
                    continue
            # --- End of custom code

            res.append(
                await self._aspace.write_attribute_value(writevalue.NodeId, writevalue.AttributeId, dv)
            )
        return res
...

server = Server()
server.iserver.attribute_service = CustomAttributeService(server.iserver.aspace)
...

This does seem to work (testing with UaExpert) as I'm now getting the desired "Write to node ... failed [ret = Bad_OutOfRange]" message logged in UaExpert.
However, this solution does not feel right since I'm directly changing member variables of the InternalServer class. I feel that it would be better to do this using some kind of callback mechanism (ideally something like subscribe_server_callback(CallbackType.PreWrite, ...) but not on the server level but on a per-node basis).

Is there something that I'm missing which would allow me to return different status codes for the write service?
I appreciate any help as I'm still quite new to OPC UA as well as asyncua. If there is a different/better way to let clients know that the value they want to write is out of the valid range then I'm also open to suggestions.

Thanks in advance!

[schroeder-]

Then I tried to use a callback function and register it using server.subscribe_server_callback(CallbackType.PreWrite, callback) in order to intercept the value coming from the client before it was written to the node. This does work (i.e. the callback is called before the actual write happens), but as I see it, there is no possibility to "return early" from the whole write process.

Did you try to raise a exception?
raise ua.uaerrors.BadOutOfRange()
raise ServiceError(ua.StatusCodes.BadOutOfRange)

[FMeinicke]

Thank you for the fast reply!

I did not try raising exceptions since I wasn't aware that this was option (the documentation is not as good when it comes to non-basic stuff that exceeds the basic server-client-example...).

Using raise ServiceError(ua.StatusCodes.BadOutOfRange) does the trick, though. The client receives the BadOutOfRange status code and on the server, I can see the following message being logged as well: sending service fault response: The value was out of range. (BadOutOfRange).

Thanks again for the prompt help!

[FMeinicke]

I was playing around a bit more with raising the two errors you suggested because I noticed that when I use raise ua.uaerrors.BadOutOfRange() (which appeals more to me since it's less code to write) UaExpert only shows "Write failed [ret = BadInternalError]". It seems to me that process_message is not handling ua.uaerrors.UaStatusCodeErrors:

opcua-asyncio/asyncua/server/uaprocessor.py

Lines 129 to 159 in 3268568

	async def process_message(self, seqhdr, body):
	"""
	Process incoming messages.
	"""
	typeid = nodeid_from_binary(body)
	requesthdr = struct_from_binary(ua.RequestHeader, body)
	_logger.debug('process_message %r %r', typeid, requesthdr)
	try:
	return await self._process_message(typeid, requesthdr, seqhdr, body)
	except ServiceError as e:
	status = ua.StatusCode(e.code)
	response = ua.ServiceFault()
	response.ResponseHeader.ServiceResult = status
	_logger.error("sending service fault response: %s (%s)", status.doc, status.name)
	self.send_response(requesthdr.RequestHandle, seqhdr, response)
	return True
	except ua.uaerrors.BadUserAccessDenied:
	if self.session:
	user = self.session.user
	else:
	user = 'Someone'
	_logger.warning("%s attempted to do something they are not permitted to do", user)
	response = ua.ServiceFault()
	response.ResponseHeader.ServiceResult = ua.StatusCode(ua.StatusCodes.BadUserAccessDenied)
	self.send_response(requesthdr.RequestHandle, seqhdr, response)
	except Exception:
	_logger.exception('Error while processing message')
	response = ua.ServiceFault()
	response.ResponseHeader.ServiceResult = ua.StatusCode(ua.StatusCodes.BadInternalError)
	self.send_response(requesthdr.RequestHandle, seqhdr, response)
	return True

I simply changed

opcua-asyncio/asyncua/server/uaprocessor.py

Line 138 in 3268568

except ServiceError as e:

to

        except (ServiceError, ua.uaerrors.UaStatusCodeError) as e:

which results in UaExport now showing the correct response status code BadOutOufRange.

Do you agree with this observation or is the current behavior somehow intended?
If you like I can also open a PR for this change.

[AndreasHeine]

the proper way to model it in opc ua would be to use a "i=15318 [BaseAnalogType]" an set the Range-ExtensionObject to the limits so the clients could check before write, but thats a modelling topic...

the thing is where do you think to get the actual limits? their are not part of the variable itself!?

in order to achieve this feature you need to rewrite and create a setter, which needs to be injected and must be part of the Variables "NodeData" itself and must be called within the Addressspace Write!

opcua-asyncio/asyncua/server/address_space.py

Line 777 in 3268568

async def write_attribute_value(self, nodeid: ua.NodeId, attr: ua.AttributeIds, value: ua.DataValue) -> ua.StatusCode:

opcua-asyncio/asyncua/server/address_space.py

Line 51 in 3268568

class NodeData:

[FMeinicke]

the proper way to model it in opc ua would be to use a "i=15318 [BaseAnalogType]" an set the Range-ExtensionObject to the limits so the clients could check before write, but thats a modelling topic...

Yes, I plan to include the allowed range in that way so that clients know the allowed range beforehand. But I'd still like to do some validation on the server side since you'll never know what values clients actually send. ;)

in order to achieve this feature you need to rewrite and create a setter, which needs to be injected and must be part of the Variables "NodeData" itself and must be called within the Addressspace Write!

This sounds very interesting. I'm going to look into this as well and will report back whether using NodeData or rasing ServiceError(ua.StatusCodes.BadOutOfRange) is the better option.

In any case, thank you, as well, for the quick response. :)

[AndreasHeine]

if you want a clean solution which would benefit this project its the way only way to go (would erase the root-cause) so you can inject a setter-function on node/variable creation which can do whatever you want to check or return!

edit:

every variable could have different limit so it needs to be part of the variable itself (NodeData)

[FMeinicke]

If I understand you correctly, then the approach you suggest isn't possible with asyncua yet. I would have to implement this option to inject a setter upon variable/node creation and submit a PR?

My preferred way would be to load a NodeSet2.xml file instead of constructing the address space manually with asyncua's server API. Therefore, I would need a way to inject such a setter after the address space has already been constructed. As I understand it, this is also not yet possible, right?

[AndreasHeine]

If I understand you correctly, then the approach you suggest isn't possible with asyncua yet. I would have to implement this option to inject a setter upon variable/node creation and submit a PR?

correkt!

My preferred way would be to load a NodeSet2.xml file instead of constructing the address space manually with asyncua's server API. Therefore, I would need a way to inject such a setter after the address space has already been constructed. As I understand it, this is also not yet possible, right?

it is a necessity to overwrite it afterwards as you mentioned!

just some loud thinking below:

class NodeData:
    """
    The class is internal to asyncua and holds all the information about a Node.
    """
    def __init__(self, nodeid: ua.NodeId):
        self.nodeid = nodeid
        self.attributes: Dict[ua.AttributeIds, AttributeValue] = {}
        self.references: List[ua.ReferenceDescription] = []
        self.call = None
        self.value_setter = None

    def set_attributes(self, id: ua.AttributeIds, val: AttributeValue):
        if self.value_setter is not None and id == ua.AttributeIds.Value:
            self.value_setter(self, id, val)
            # maybe raise a error or return a statuscode...
        else:
            # as currently implemented!

    def __str__(self) -> str:
        return f"NodeData(id:{self.nodeid}, attrs:{self.attributes}, refs:{self.references})"

    __repr__ = __str__

def my_setter(id: ua.AttributeIds, val: AttributeValue):
    high = 100
    low = 0
    if val.Value.Value > high or val.Value.Value < low:
        raise ServiceError(ua.StatusCodes.BadOutOfRange)

[FMeinicke]

Thank you for confirming.

I already had something similar to your suggestions in mind. I'll see what I can come up with and open a PR once I have something ready to discuss.
Thanks again for your help so far!