Merge pull request #1389 from open62541/hotfix/inheritance

Inherit node value and modelling rule of intermediate types

src/server/ua_nodes.c

@@ -573,9 +573,7 @@ UA_Node_deleteReference(UA_Node *node, const UA_DeleteReferencesItem *item) {
 void UA_Node_deleteReferences(UA_Node *node) {
     for(size_t i = 0; i < node->referencesSize; ++i) {
         UA_NodeReferenceKind *refs = &node->references[i];
-        for(size_t j = 0; j < refs->targetIdsSize; ++j)
-            UA_ExpandedNodeId_deleteMembers(&refs->targetIds[j]);
-        UA_free(refs->targetIds);
+        UA_Array_delete(refs->targetIds, refs->targetIdsSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
         UA_NodeId_deleteMembers(&refs->referenceTypeId);
     }
     if(node->references)

src/server/ua_services_nodemanagement.c

@@ -335,6 +335,77 @@ static void
 addReference(UA_Server *server, UA_Session *session,
              const UA_AddReferencesItem *item, UA_StatusCode *retval);
 
+
+/*
+ * This method only deletes references from the node which are not matching any type in the given array.
+ * Could be used to e.g. delete all the references, except 'HASMODELINGRULE'
+ */
+static void deleteReferencesSubset(UA_Node *node, size_t referencesSkipSize, UA_NodeId* referencesSkip) {
+    if (referencesSkipSize == 0) {
+        UA_Node_deleteReferences(node);
+        return;
+    }
+
+    /* Let's count if there are references left. If not just delete all the references.
+     * It's faster */
+    size_t newSize = 0;
+    for(size_t i = 0; i < node->referencesSize; ++i) {
+        for (size_t j = 0; j < referencesSkipSize; j++) {
+            if (UA_NodeId_equal(&node->references[i].referenceTypeId, &referencesSkip[j])) {
+                newSize++;
+            }
+        }
+    }
+    if (newSize == 0){
+        UA_Node_deleteReferences(node);
+        return;
+    }
+
+    /* Now copy the remaining references to a new array */
+    UA_NodeReferenceKind *newReferences = (UA_NodeReferenceKind *)UA_malloc(sizeof(UA_NodeReferenceKind) * (newSize));
+    size_t curr = 0;
+    UA_StatusCode retval = UA_STATUSCODE_GOOD;
+    for(size_t i = 0; i < node->referencesSize && retval == UA_STATUSCODE_GOOD; ++i) {
+        for (size_t j = 0; j < referencesSkipSize; j++) {
+            if (!UA_NodeId_equal(&node->references[i].referenceTypeId, &referencesSkip[j]))
+                continue;
+
+            // copy the reference
+            UA_NodeReferenceKind *srefs = &node->references[i];
+            UA_NodeReferenceKind *drefs = &newReferences[curr++];
+            drefs->isInverse = srefs->isInverse;
+            retval = UA_NodeId_copy(&srefs->referenceTypeId, &drefs->referenceTypeId);
+            if(retval != UA_STATUSCODE_GOOD)
+                break;
+            retval = UA_Array_copy(srefs->targetIds, srefs->targetIdsSize,
+                                   (void**)&drefs->targetIds,
+                                   &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
+            if(retval != UA_STATUSCODE_GOOD)
+                break;
+            drefs->targetIdsSize = srefs->targetIdsSize;
+            break;
+        }
+        if (retval != UA_STATUSCODE_GOOD) {
+            for (size_t k=0; k<i; k++) {
+                UA_NodeReferenceKind *refs = &newReferences[i];
+                for(size_t j = 0; j < refs->targetIdsSize; ++j)
+                    UA_ExpandedNodeId_deleteMembers(&refs->targetIds[j]);
+                UA_Array_delete(refs->targetIds, refs->targetIdsSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
+                UA_NodeId_deleteMembers(&refs->referenceTypeId);
+            }
+        }
+    }
+
+    UA_Node_deleteReferences(node);
+    if (retval == UA_STATUSCODE_GOOD) {
+        node->references = newReferences;
+        node->referencesSize = newSize;
+    } else {
+        UA_free(newReferences);
+    }
+}
+
+
 static UA_StatusCode
 copyChildNode(UA_Server *server, UA_Session *session,
               const UA_NodeId *destinationNodeId,
@@ -399,7 +470,9 @@ copyChildNode(UA_Server *server, UA_Session *session,
         /* TODO: Be more clever in removing references that are re-added during
          * addnode_finish. That way, we can call addnode_finish also on children that were
          * manually added by the user during addnode_begin and addnode_finish. */
-        UA_Node_deleteReferences(node);
+        /* For now we keep all the modelling rule references and delete all others */
+        UA_NodeId modellingRuleReferenceId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASMODELLINGRULE);
+        deleteReferencesSubset(node, 1, &modellingRuleReferenceId);
 
         /* Add the node to the nodestore */
         UA_NodeId newNodeId;
@@ -409,8 +482,14 @@ copyChildNode(UA_Server *server, UA_Session *session,
             return retval;
         }
 
-        /* Call addnode_finish, this recursively adds members, the type
-         * definition and so on */
+        /* Add all the children of this child to the new child node to make sure we take
+         * the values from the nearest inherited object first.
+         */
+        copyChildNodes(server, session, &rd->nodeId.nodeId, &newNodeId);
+
+        /* Call addnode_finish, this recursively adds additional members, the type
+         * definition and so on of the base type of this child, if they are not yet
+         * in the destination */
         retval = Operation_addNode_finish(server, session, &newNodeId, destinationNodeId,
                                           &rd->referenceTypeId, typeId);
         UA_NodeId_deleteMembers(&newNodeId);

tests/CMakeLists.txt

@@ -136,6 +136,10 @@ add_executable(check_server_userspace server/check_server_userspace.c $<TARGET_O
 target_link_libraries(check_server_userspace ${LIBS})
 add_test_valgrind(check_server_userspace ${TESTS_BINARY_DIR}/check_server_userspace)
 
+add_executable(check_node_inheritance server/check_node_inheritance.c $<TARGET_OBJECTS:open62541-object> $<TARGET_OBJECTS:open62541-testplugins>)
+target_link_libraries(check_node_inheritance ${LIBS})
+add_test_valgrind(check_node_inheritance ${TESTS_BINARY_DIR}/check_node_inheritance)
+
 if(UA_ENABLE_DISCOVERY)
     add_executable(check_discovery server/check_discovery.c $<TARGET_OBJECTS:open62541-object> $<TARGET_OBJECTS:open62541-testplugins>)
     target_link_libraries(check_discovery ${LIBS})

tests/server/check_node_inheritance.c

@@ -0,0 +1,214 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ua_server.h"
+#include "server/ua_server_internal.h"
+#include "ua_config_default.h"
+
+#include "check.h"
+
+UA_Server *server = NULL;
+UA_ServerConfig *config = NULL;
+
+UA_UInt32 valueToBeInherited = 42;
+
+static void setup(void) {
+    config = UA_ServerConfig_new_default();
+    server = UA_Server_new(config);
+    UA_Server_run_startup(server);
+}
+
+static void teardown(void) {
+    UA_Server_run_shutdown(server);
+    UA_Server_delete(server);
+    UA_ServerConfig_delete(config);
+}
+
+
+/* finds the NodeId of a StateNumber child of a given node id */
+static void findChildId(UA_NodeId stateId, UA_NodeId referenceType, const UA_QualifiedName targetName, UA_NodeId *result) {
+    UA_RelativePathElement rpe;
+    UA_RelativePathElement_init(&rpe);
+    rpe.referenceTypeId = referenceType;
+    rpe.isInverse = false;
+    rpe.includeSubtypes = false;
+    rpe.targetName = targetName;
+
+    UA_BrowsePath bp;
+    UA_BrowsePath_init(&bp);
+    bp.startingNode = stateId;
+    bp.relativePath.elementsSize = 1;
+    bp.relativePath.elements = &rpe;    //clion complains but is ok
+
+    UA_BrowsePathResult bpr = UA_Server_translateBrowsePathToNodeIds(server, &bp);
+    ck_assert_uint_eq(bpr.statusCode, UA_STATUSCODE_GOOD);
+
+
+    UA_NodeId_copy(&bpr.targets[0].targetId.nodeId, result);
+    UA_BrowsePathResult_deleteMembers(&bpr);
+}
+
+
+START_TEST(Nodes_createCustomStateType)
+    {
+        // Create a type "CustomStateType" with a variable "CustomStateNumber" as property
+        UA_StatusCode retval = UA_STATUSCODE_GOOD;
+
+        UA_ObjectTypeAttributes attrObject = UA_ObjectTypeAttributes_default;
+        attrObject.displayName = UA_LOCALIZEDTEXT("", "CustomStateType");
+        attrObject.description = UA_LOCALIZEDTEXT("", "");
+        attrObject.writeMask = 0;
+        attrObject.userWriteMask = 0;
+        retval = UA_Server_addObjectTypeNode(server,
+                                             UA_NODEID_NUMERIC(1, 6000),
+                                             UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE),
+                                             UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),
+                                             UA_QUALIFIEDNAME(1, "CustomStateType"),
+                                             attrObject,
+                                             NULL, NULL);
+        ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+
+        // Now add a property "StateNumber"
+        UA_VariableAttributes attr = UA_VariableAttributes_default;
+        attr.minimumSamplingInterval = 0.000000;
+        attr.userAccessLevel = 1;
+        attr.accessLevel = 1;
+        attr.valueRank = -2;
+        attr.dataType = UA_NODEID_NUMERIC(0, UA_NS0ID_UINT32);
+        UA_UInt32 val = 0;
+        UA_Variant_setScalar(&attr.value, &val, &UA_TYPES[UA_TYPES_UINT32]);
+        attr.displayName = UA_LOCALIZEDTEXT("", "CustomStateNumber");
+        attr.description = UA_LOCALIZEDTEXT("", "");
+        attr.writeMask = 0;
+        attr.userWriteMask = 0;
+        retval = UA_Server_addVariableNode(server,
+                                           UA_NODEID_NUMERIC(1, 6001),
+                                           UA_NODEID_NUMERIC(1, 6000),
+                                           UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY),
+                                           UA_QUALIFIEDNAME(1, "CustomStateNumber"),
+                                           UA_NODEID_NUMERIC(0, UA_NS0ID_PROPERTYTYPE),
+                                           attr,
+                                           NULL, NULL);
+        ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+
+        retval = UA_Server_addReference(server, UA_NODEID_NUMERIC(1, 6001), UA_NODEID_NUMERIC(0, UA_NS0ID_HASMODELLINGRULE),
+                                        UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_MODELLINGRULE_MANDATORY), true);
+        ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+
+    }
+END_TEST
+
+
+START_TEST(Nodes_createCustomObjectType)
+    {
+        // Create a custom object type "CustomDemoType" which has a "CustomStateType" component
+
+        UA_StatusCode retval = UA_STATUSCODE_GOOD;
+
+        /* create new object type node which has a subcomponent of the type StateType */
+        UA_ObjectTypeAttributes otAttr = UA_ObjectTypeAttributes_default;
+        otAttr.displayName = UA_LOCALIZEDTEXT("", "CustomDemoType");
+        otAttr.description = UA_LOCALIZEDTEXT("", "");
+        retval = UA_Server_addObjectTypeNode(server, UA_NODEID_NUMERIC(1, 6010),
+                                             UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE),
+                                             UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),
+                                             UA_QUALIFIEDNAME(1, "CustomDemoType"),
+                                             otAttr, NULL, NULL);
+        ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+
+
+        UA_ObjectAttributes oAttr = UA_ObjectAttributes_default;
+        oAttr.displayName = UA_LOCALIZEDTEXT("", "State");
+        oAttr.description = UA_LOCALIZEDTEXT("", "");
+        retval = UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 6011), UA_NODEID_NUMERIC(1, 6010),
+                                         UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+                                         UA_QUALIFIEDNAME(1, "State"),
+                                         UA_NODEID_NUMERIC(1, 6000),
+                                         oAttr, NULL, NULL);
+        ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+
+
+        /* modelling rule is mandatory so it will be inherited for the object created from CustomDemoType */
+        retval = UA_Server_addReference(server, UA_NODEID_NUMERIC(1, 6011), UA_NODEID_NUMERIC(0, UA_NS0ID_HASMODELLINGRULE),
+                                        UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_MODELLINGRULE_MANDATORY), true);
+        ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+
+
+
+
+        /* assign a default value to the attribute "StateNumber" inside the state attribute (part of the MyDemoType) */
+        UA_Variant stateNum;
+        UA_Variant_init(&stateNum);
+        UA_Variant_setScalar(&stateNum, &valueToBeInherited, &UA_TYPES[UA_TYPES_UINT32]);
+        UA_NodeId childID;
+        findChildId(UA_NODEID_NUMERIC(1, 6011), UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY),
+                    UA_QUALIFIEDNAME(1, "CustomStateNumber"), &childID);
+        ck_assert(!UA_NodeId_isNull(&childID));
+
+        retval = UA_Server_writeValue(server, childID, stateNum);
+        ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+
+    }
+END_TEST
+
+START_TEST(Nodes_createInheritedObject)
+    {
+        /* create an object/instance of the demo type */
+        UA_ObjectAttributes oAttr2 = UA_ObjectAttributes_default;
+        oAttr2.displayName = UA_LOCALIZEDTEXT("", "Demo");
+        oAttr2.description = UA_LOCALIZEDTEXT("", "");
+        UA_StatusCode retval = UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 6020),
+                                                       UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                                       UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+                                                       UA_QUALIFIEDNAME(1, "Demo"), UA_NODEID_NUMERIC(1, 6010),
+                                                       oAttr2, NULL, NULL);
+        ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
+    }
+END_TEST
+
+START_TEST(Nodes_checkInheritedValue)
+    {
+        UA_NodeId childState;
+        findChildId(UA_NODEID_NUMERIC(1, 6020), UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
+                    UA_QUALIFIEDNAME(1, "State"), &childState);
+        ck_assert(!UA_NodeId_isNull(&childState));
+        UA_NodeId childNumber;
+        findChildId(childState, UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY),
+                    UA_QUALIFIEDNAME(1, "CustomStateNumber"), &childNumber);
+        ck_assert(!UA_NodeId_isNull(&childNumber));
+
+        UA_Variant inheritedValue;
+        UA_Variant_init(&inheritedValue);
+        UA_Server_readValue(server, childNumber, &inheritedValue);
+        ck_assert(inheritedValue.type == &UA_TYPES[UA_TYPES_UINT32]);
+
+        UA_UInt32 *value = (UA_UInt32 *) inheritedValue.data;
+
+        ck_assert_int_eq(*value, valueToBeInherited);
+        UA_Variant_deleteMembers(&inheritedValue);
+    }
+END_TEST
+
+
+static Suite *testSuite_Client(void) {
+    Suite *s = suite_create("Node inheritance");
+    TCase *tc_inherit_subtype = tcase_create("Inherit subtype value");
+    tcase_add_unchecked_fixture(tc_inherit_subtype, setup, teardown);
+    tcase_add_test(tc_inherit_subtype, Nodes_createCustomStateType);
+    tcase_add_test(tc_inherit_subtype, Nodes_createCustomObjectType);
+    tcase_add_test(tc_inherit_subtype, Nodes_createInheritedObject);
+    tcase_add_test(tc_inherit_subtype, Nodes_checkInheritedValue);
+    suite_add_tcase(s, tc_inherit_subtype);
+    return s;
+}
+
+int main(void) {
+    Suite *s = testSuite_Client();
+    SRunner *sr = srunner_create(s);
+    srunner_set_fork_status(sr, CK_NOFORK);
+    srunner_run_all(sr, CK_NORMAL);
+    int number_failed = srunner_ntests_failed(sr);
+    srunner_free(sr);
+    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+}