client_handle implementation change proposal

[rockonedege]

In my case, I need to develop an application to connect 5 PLCs concurrently, which means 5 OPCUA clients.

The 5 clients share one single subscription instance, and node ids happen to be identical so, the only way to tell the target of data changes is from the client_handle, in the current implementation (as of v0.9.95) is an instantance member which is duplicated among teh 5 clients, making it useless.

I am proposing to change client_handle to be a class member as below

## before
class Subscription:
    """
    Subscription object returned by Server or Client objects.
    The object represent a subscription to an opc-ua server.
    This is a high level class, especially `subscribe_data_change` and `subscribe_events methods`.
    If more control is necessary look at code and/or use `create_monitored_items method`.
    :param server: `InternalSession` or `UAClient`
    """


    def __init__(self, server, params: ua.CreateSubscriptionParameters, handler: SubHandler):
        self.logger = logging.getLogger(__name__)
        self.server = server
        self. _client_handle = 200
        ...

## after
class Subscription:
    """
    Subscription object returned by Server or Client objects.
    The object represent a subscription to an opc-ua server.
    This is a high level class, especially `subscribe_data_change` and `subscribe_events methods`.
    If more control is necessary look at code and/or use `create_monitored_items method`.
    :param server: `InternalSession` or `UAClient`
    """

    _client_handle = 200
    def __init__(self, server, params: ua.CreateSubscriptionParameters, handler: SubHandler):
        self.logger = logging.getLogger(__name__)
        self.server = server
       ...

if this is acceptable, I could submitt a PR

[schroeder-]

This is more a user thing, you can add as many variables to our subscription handler. No need to implement this in the library.

class MyHandler:
  def __init__(client_id, client_handle):
  ....

handler = MyHandler(id, client)

[rockonedege]

I did not make myself clear. Let me try it again.

there are 5 OPC UA servers running on 5 PLCs. On each server, there's one Variable to be subscribed, all with the same node is, say ns=4:s=semaphor,

when the changes come back to the client, with the current signature(client_handle, node, val), it's not possible to tell which 1 of the 5 clients to respond, as client_handle and node are the same, the former by library design, in this case client_handle=1 always, the latter by application design, in this case ns=4:s=semaphor always.

[oroulet]

if you subscribe with the same handler for all of them yes you have an issue, but you can easily have 5 different handlers, each with their own id that call a common handler with the id a argument

[schroeder-]

Here is a full example with what i mean, how do know which client has a changed variable:

class SubscriptionHandler:
     def __init__(self, url, id):
          self._url = url
          self._id = id
   
     def datachange_notification(self, node: Node, val, data):
        """
        Callback for asyncua Subscription.
        This method will be called when the Client received a data change message from the Server.
        """
        _logger.info(f'datachange_notification Client: {self._url} : {self._id} {node} {val}')


urls = ['opc.tcp://xxxx', ...... ]
clients = []

for idx, url in enumerate(urls):
    client = Client(url)
    await client.connect()
    handler= SubscriptionHandler(url, idx)
    nodes = [....]
    subscription = await client.create_subscription(500, handler)
    await subscription.subscribe_data_change(nodes)
    clients.append(client)
.....

[rockonedege]

works like charm. Thanks.

I thought I had(or better ) to use only one instance of handler to multiplex all changes. It turned out I could actually use one for each client.