How do I identify the calling node in a method callback?

[Randelung]

Hello!

As the title says, I'm trying to identify where a callback came from. I see from the source code that the arguments to the callback are the PARENT and the argument values. Project guidelines dictate several methods in one folder, so all methods would return the same parent ID.
Are you supposed to use a partial/lambda and supply a flag or are there other mechanisms to get the ID of the actual method node?

Or am I just misunderstanding OPC UA methods? :)

Also, is it possible to add/override the callback after node generation? I'd use server.add_method_callback again, is that safe?

Thanks for your help!

[oroulet]

you cannot.
Also as far as I know using the caller to change the behviour of a method is bad progamming idea and is not possible in languages I know

[Randelung]

I think there might be a misunderstanding.
Using the caller to change the behavior of a method? I'm trying to identify what method is being called in the first place. If I have two methods root.add and root.multiply and all I'm getting in my callback is root I don't know what to do...
Which is why I asked about my misunderstanding the OPC fundamentals - I find it hard to believe that it's impossible to find out which method was actually called on the OPC interface.
I'd have to implement a unique callback for each method... which is why I'm asking about partials/lambdas and what the intended usage is supposed to be.

[oroulet]

Ok. I understand. What is the issue of having two callbacks? Usually you want to map UA methods to some internal methods which are different anyway.
Also no problems in calling add_method_callbak many times but I have issues understanding why one would do that..

[oroulet]

And yes the only think getting passed to the method is the parent. No ideas why it is passed. I have never used it

[AndreasHeine]

No ideas why it is passed.

spec. wants it... its part of "Call Service Parameters"
https://reference.opcfoundation.org/v104/Core/docs/Part4/5.11.2/

objectId	NodeId	The NodeId shall be that of the Object or ObjectType on which the Method is invoked.In case of an ObjectType the ObjectType or a super type of the ObjectType shall be the source of a HasComponent Reference (or subtype of HasComponent Reference) to the Method specified in methodId.In case of an Object the Object or the ObjectType of the Object or a super type of that ObjectType shall be the source of a HasComponent Reference (or subtype of HasComponent Reference) to the Method specified in methodId.See OPC 10000-3 for a description of Objects and their Methods.
methodId	NodeId	NodeId   of the Method to invoke.If the objectId is the NodeId of an Object, it is allowed to use the NodeId of a Method that is the target of a HasComponent Reference from the ObjectType of the Object.

[Randelung]

Is it possible to access the methodId, too? That would be exactly what I'm referring to.

The reason I'm asking is that I'll have about 8'000 methods, all performing similar tasks. For each object there's usually two methods that do different things, but the objects are all very similar. The callbacks in question would therefore be identical, except for the target they mutate. Ideally, it would come down to a dict lookup to get from method node(Id) to target object.

Now, for me it's not really an issue since I'm passing my own GUIDs to the method. In my case I can just wrap the callback in a partial and pass the GUID to which I already have access. I'm just wondering what I should do if I didn't have those IDs handy already. The fact that the parent nodeId is given just confused me since either

a) you're expected to pass your own parameters in a partial, anyway, and since you're creating a node you have a reference to
the parent yourself, which means there wouldn't really be a need for the parent ID to be a parameter in the first place, or

b) wrapping in a partial is NOT the intended usage, in which case the method nodeId would need to be accessible somehow (which apparently according to the spec it should be),
or

c) I'm misunderstanding something else, in which case it'll probably bite me later on in my own application.
I'm trying to do it the way it was intended before looking for a possibly more convoluted workaround.

(Am I making sense?)

As a tangent: the objectId gives me a folder node since the direct parent of the methods in question are folders. All methods are grandchildren of objects, but not (yet) linked to the object in any datatype kind of way. Maybe returning the direct parent is not sufficient. Also, if a method does not necessarily need to be descendant of an object, that objectId may possibly even be None.

Regarding the add_method_callback, I'm just looking for possibilities at this point. If you have bidirectional data flow between two objects, one of the callbacks needs to have the ability to initialize first and then assign a callback. If I want to initialize the OPC layer first and then connect my internal models to the nodes the nodes need to exist first.
Otherwise I need some sort of intermediary code that registers both objects and does None checking and all that.

[AndreasHeine]

pew... need to read it twice🤔

[swamper123]

Okay, what I understand now is:

• how do I get the NodeID of the Method, which is/was executing/ed?
• is there an OPC UA conform way to figure it out?
• may I have to use add_method_callback for that?

What I found out (please correct me if I'm wrong, my brain is melting at the moment), there is an EventType AuditUpdateMethodEventType which contains the methodID. This Event can be subtyped for further purposes.
Can this leads to your goal? That you are subscribing to such events to know which method was called (they got a TimeStamp when this action was initiated)?

Edit: AuditUpdateMethodEventType is a subtype from AuditEventType.

[Randelung]

Sorry if it's all over the place. I'll try to unmelt your brain. There was three things going on in my last comment.

1. Can I get the Node reference or NodeId as a parameter in a method callback?
2. (the tangent) Is is correct to see obectId as mandated in the spec as equal to the parentId?
3. Is it possible to use add_method_callback after initialization is complete to override a dummy callback?

1 is the main question.
I'm adding a method using add_method and passing a callback that accepts a NodeId and a VariantType as commented in the create_method function in the code.
It appears to me that only getting the parent ID and not the actual ID of the node itself is wrong, as there is no way to identify which method was invoked other than the context of the actual callback that was called ("I'm in callback1, therefore I know method1 was called"). In order to differentiate between methods, each method needs its own unique callback.
Looking at the Spec linked above by AndreasHeine it seems that it should be possible to receive both the node ID of the called method as well as the object ID on which the method was invoked, which I'm interpreting is the next object ancestor (not necessarily the direct parent).

2 is a consequence of the last point in 1. As oroulet states he doesn't know where the parameter comes from and AndreasHeine is equating it to the objectId parameter in the spec, I'm thinking passing the direct parent of a method regardless of its type is wrong.
Instead of passing the parent, an ancestor would have to be found that is an object, and if there is none, the parameter might just be None. (Depends if a method needs to be descendant of an object or not, which I don't know.)

3 is pretty much clear now. I can use add_method_callback to modify callbacks after method creation in order to link a python object method to an OPC method even if the python object can only be initialized after creating the OPC method. (E. g. if I need the dynamically created node ID of the method in the other python object.)

Thank you swamper123 for your suggestion. I don't know if that would get me where I want to be, but I also don't intend to try (also I can't even begin to understand where these EventTypes even come into play :D) since I have a workaround in mind already. I can call a common python function that requires the method node ID by calling it in a function partial/lambda function that itself uses the predefined GUID I'm using to create the method.
Also, since point 3 is cleared up, I can reassign the callback after initializing the method node, so I have access to the node ID even if I'm not explicitly defining it myself at method creation time.

After this I'm gathering that

• no, I cannot get the method node ID as a parameter, and this isn't spec conform.
• The parent ID parameter might be a misinterpretation of the objectId spec or just something entirely different.
• There isn't really a correct way ("as the creators intended") to do what I want to do
• A workaround to reuse callback code is to create a partial and supply a flag on which to branch, and
• if you need the dynamic node ID of a method in the callback, create the method, receive the ID as result, and reassign the callback to a partial that uses said node ID using add_method_callback.

This basically summarizes my thoughts so far. Are my conclusions correct?

[AndreasHeine]

https://github.com/FreeOpcUa/opcua-asyncio/blob/master/asyncua/common/methods.py

did not found any hint in the specs... but it should be possible to pass the methodid together with the parent on all "call_method" methods! otherwise i dont see a chance to get the methodid itself from parent because you said that all have the same parent...