Issue creating NonTransparentRedundancyType node

[parvit]

Describe the bug
Hi, i'm trying to implement the Redundancy Visible Server Facet in my milo server, so i need to create a NonTransparentRedundancyType node in the node manager.

Optional<UaNode> serverNode = mgr.getManagedNode( Identifiers.Server );
Optional<UaNode> redundancyNode = mgr.getManagedNode( Identifiers.Server_ServerRedundancy );
if( redundancyNode.isPresent() ) {
  try {
    UaObjectNode srvNode = (UaObjectNode)serverNode.get();
    UaObjectNode parent = (UaObjectNode)redundancyNode.get();

    Tree<UaNode> objectNodes = getNodeFactory().createNodeTree(parent.getNodeId(), Identifiers.NonTransparentRedundancyType, new NodeFactory.InstantiationCallback() {
      @Override
      public void onObjectAdded(@Nullable UaNode parent, UaObjectNode instance, NodeId typeDefinitionId) {
        getNodeManager().addNode( instance );
      }

      @Override
      public void onVariableAdded(@Nullable UaNode parent, UaVariableNode instance, NodeId typeDefinitionId) {
        getNodeManager().addNode( instance );
      }
    });

    srvNode.addComponent( objectNodes.getValue() );
    getNodeManager().addNode( objectNodes.getValue() );

  } catch (UaException e) {
    throw new RuntimeException(e);
  }
}

What i get in the UaExpert is:

I'm new to opc-ua development so i'm sure i'm doing something wrong in the code above, any help would be appreciated.

EDIT: This is implemented in a subclass of ManagedAddressSpaceFragmentWithLifecycle

[kevinherron]

This is Kotlin, so you'll have to squint a little, but when creating these Nodes in our server I use a custom NodeFactory instance because it's a little tricky to create Nodes that belong to another Namespace, and also force that new instance to use existing NodeIds.

        private fun redundancyNodeFactory(): NodeFactory {
            return object : NodeFactory(opcUaNamespace.getNodeContext()) {
                override fun instanceNodeId(rootNodeId: NodeId, browsePath: BrowsePath): NodeId {
                    return if (rootNodeId == Identifiers.Server_ServerRedundancy) {
                        when (browsePath.join()) {
                            "/0:RedundancySupport" -> Identifiers.Server_ServerRedundancy_RedundancySupport
                            "/0:ServerUriArray" -> Identifiers.Server_ServerRedundancy_ServerUriArray
                            else -> super.instanceNodeId(rootNodeId, browsePath)
                        }
                    } else {
                        super.instanceNodeId(rootNodeId, browsePath)
                    }
                }
            }
        }

Note that this NodeFactory is using the UaNodeContext from OpcUaNamespace, which I had to retrieve via reflection, unfortunately. I think I need to change all the protected accessors on ManagedAddressSpace to public so this isn't so awkward.

Then you can re-create the ServerRedundancyNode:

                val serverRedundancyNode: UaNode = redundancyNodeFactory().createNode(
                    Identifiers.Server_ServerRedundancy,
                    Identifiers.NonTransparentRedundancyType
                )