Calling method fails with "Bad_NotFound"

[mynickistak]

Hi,

we use Milo 0.6.3 for calling OPC-UA methods.
It fails on methods we want to call with an "status=Bad_NotFound" UaException with our application. But there are no problems in UA Expert (screenshot). Our prototype works fine with an other available method.

we get:

UaException: status=Bad_NotFound, message=method not found: QualifiedName{name=Method, namespaceIndex=3}
	at org.eclipse.milo.opcua.sdk.client.nodes.UaObjectNode.lambda$getMethodAsync$9(UaObjectNode.java:282)

// our call method prototype:
public Variant[] callMethode(/* */) throws UaRuntimeException, UaException {
    
        // an other method => works fine
        // String nodeOk = "i=2253";
        // String methodNameOk = "GetMonitoredItems";
    
        // method we want to call => fails
        node = "ns=3;s=\"OPCUA_methodCmd_IDB\"";
        methodName = "Method"; 
         
        // works fine, objectNode finds "Method" too
        UaObjectNode objectNode = client.getAddressSpace().getObjectNode(NodeId.parse(node));
    
        // throws an "UaException: status=Bad_NotFound, message=method not found: QualifiedName{name=Method, namespaceIndex=3}"
        UaMethod evilMethod = objectNode.getMethod(methodName);
        // no calling method for us ;-(
		// but it works in UA Expert
        output = evilMethod.call(inputValues);
        
}

This exception comes from UaObjectNode.getMethodAsync(QualifiedName):

				/* ... */
                return methodNodeId
                    .map(xni -> {
                        AddressSpace addressSpace = client.getAddressSpace();

                        return addressSpace.toNodeIdAsync(xni).thenCompose(
                            nodeId ->
                                addressSpace.getNodeAsync(nodeId).thenCompose(node -> {
                                    UaMethodNode methodNode = (UaMethodNode) node;

                                    CompletableFuture<Argument[]> inputArguments =
                                        methodNode.readInputArgumentsAsync()
                                            .exceptionally(t -> new Argument[0]);

                                    CompletableFuture<Argument[]> outputArguments =
                                        methodNode.readOutputArgumentsAsync()
                                            .exceptionally(t -> new Argument[0]);

                                    return inputArguments.thenCombine(
                                        outputArguments,
                                        (in, out) -> new UaMethod(client, this, methodNode, in, out)
                                    );
                                })
                        );
                    })
                    .orElse(failedFuture(new UaException(StatusCodes.Bad_NotFound, "method not found: " + methodName)));

I found some issues regarding input / output parameters but they there fixed in ##815 and 816, its already in our Milo 0.6.3.
Coult it still be some parameter problem? I'm not sure if it's an PLC oder Milo issue.

UA Expert on method which fails in our application:

[kevinherron]

I believe you are running into a confirmed bug with the Siemens S7-1500 OPC UA server. As you can see prior to the snippet, the client does a browse from the ObjectNode for forward references of the HasComponent type, and when the browse is narrowed like this the server has a bug that results in the MethodNode not being returned.

https://github.com/eclipse/milo/blob/17a8fc8d14893e3e4532a9237789363b8cc50891/opc-ua-sdk/sdk-client/src/main/java/org/eclipse/milo/opcua/sdk/client/nodes/UaObjectNode.java#L256-L269

[kevinherron]

Here is a snippet from an email conversation with somebody else about this:

I received confirmation that this is a bug in the Siemens server where it does not handle the NodeClassMask correctly:

I just checked the code and tracked it down to a CTT error that occurred with our current implementation.
The corresponding referenced testcase was Services/View Basic/006

I believe the issue is there since we introduced Methods.
The issue seems to be an incorrect handling of the NodeClassMask.

We will integrate the fix into our next release.

In the meantime you could probably call methods on your own something like this:

AddressSpace addressSpace = client.getAddressSpace();

UaObjectNode objectNode = addressSpace.getObjectNode(...);
UaMethodNode methodNode = (UaMethodNode) addressSpace.getNode(...);

UaMethod method = methodNode.readInputArgumentsAsync().thenCombine(
    methodNode.readOutputArgumentsAsync(),
    (in, out) -> new UaMethod(client, objectNode, methodNode, in, out)
).get();

method.call(new Variant[]{...});

If you don't know the NodeId of the UaMethodNode ahead of time then you could use AddressSpace::browseNodes to find it yourself, making sure that the general BrowseOptions are the default and include everything:

Optional<? extends UaNode> methodNode = addressSpace.browseNodes(objectNode).stream()
    .filter(n -> n.getNodeClass() == NodeClass.Method)
    .filter(n -> n.getBrowseName().getName().equals("Method"))
    .findFirst();

Probably wrapping this all into a utility function very similar to UaObjectNode::getMethodAsync would make sense.

[mynickistak]

Thank you for your help! (And your great work for Milo Project of course, too). I'm on holiday right now but I will try it out later.