diff --git a/examples/pubsub/pubsub_subscribe_encrypted.c b/examples/pubsub/pubsub_subscribe_encrypted.c index 388df8b8a..fd4756272 100644 --- a/examples/pubsub/pubsub_subscribe_encrypted.c +++ b/examples/pubsub/pubsub_subscribe_encrypted.c @@ -135,8 +135,8 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { * received DataSet fields and target Variables in the Subscriber AddressSpace. * The values subscribed from the Publisher are updated in the value field of these variables */ /* Create the TargetVariables with respect to DataSetMetaData fields */ - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -152,18 +152,13 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { UA_QUALIFIEDNAME(1, (char *)readerConfig.dataSetMetaData.fields[i].name.data), UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newNode); - - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(&targetVars[i].targetVariable); - targetVars[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars[i].targetVariable.targetNodeId = newNode; + targetVars[i].attributeId = UA_ATTRIBUTEID_VALUE; + targetVars[i].targetNodeId = newNode; } UA_Server_DataSetReader_createTargetVariables(server, dataSetReaderId, readerConfig.dataSetMetaData.fieldsSize, targetVars); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); UA_free(targetVars); UA_free(readerConfig.dataSetMetaData.fields); diff --git a/examples/pubsub/pubsub_subscribe_encrypted_tpm.c b/examples/pubsub/pubsub_subscribe_encrypted_tpm.c index 264aa1188..09e6235fe 100644 --- a/examples/pubsub/pubsub_subscribe_encrypted_tpm.c +++ b/examples/pubsub/pubsub_subscribe_encrypted_tpm.c @@ -142,8 +142,8 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { * received DataSet fields and target Variables in the Subscriber AddressSpace. * The values subscribed from the Publisher are updated in the value field of these variables */ /* Create the TargetVariables with respect to DataSetMetaData fields */ - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType *) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -160,17 +160,13 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newNode); - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(&targetVars[i].targetVariable); - targetVars[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars[i].targetVariable.targetNodeId = newNode; + targetVars[i].attributeId = UA_ATTRIBUTEID_VALUE; + targetVars[i].targetNodeId = newNode; } UA_Server_DataSetReader_createTargetVariables(server, dataSetReaderId, readerConfig.dataSetMetaData.fieldsSize, targetVars); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); UA_free(targetVars); UA_free(readerConfig.dataSetMetaData.fields); diff --git a/examples/pubsub/pubsub_subscribe_encrypted_tpm_keystore.c b/examples/pubsub/pubsub_subscribe_encrypted_tpm_keystore.c index 44348f4dd..8d37d1366 100644 --- a/examples/pubsub/pubsub_subscribe_encrypted_tpm_keystore.c +++ b/examples/pubsub/pubsub_subscribe_encrypted_tpm_keystore.c @@ -178,8 +178,8 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { * received DataSet fields and target Variables in the Subscriber AddressSpace. * The values subscribed from the Publisher are updated in the value field of these variables */ /* Create the TargetVariables with respect to DataSetMetaData fields */ - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -196,16 +196,12 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newNode); - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(&targetVars[i].targetVariable); - targetVars[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars[i].targetVariable.targetNodeId = newNode; + targetVars[i].attributeId = UA_ATTRIBUTEID_VALUE; + targetVars[i].targetNodeId = newNode; } retval = UA_Server_DataSetReader_createTargetVariables(server, dataSetReaderId, readerConfig.dataSetMetaData.fieldsSize, targetVars); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); UA_free(targetVars); UA_free(readerConfig.dataSetMetaData.fields); diff --git a/examples/pubsub/server_pubsub_subscribe_custom_monitoring.c b/examples/pubsub/server_pubsub_subscribe_custom_monitoring.c index c9a340dd0..cf3179ef8 100644 --- a/examples/pubsub/server_pubsub_subscribe_custom_monitoring.c +++ b/examples/pubsub/server_pubsub_subscribe_custom_monitoring.c @@ -123,8 +123,8 @@ addSubscribedVariables(UA_Server *server, UA_NodeId dataSetReaderId) { UA_NS0ID(BASEOBJECTTYPE), oAttr, NULL, &folderId); /* Create the TargetVariables with respect to DataSetMetaData fields */ - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -141,15 +141,14 @@ addSubscribedVariables(UA_Server *server, UA_NodeId dataSetReaderId) { UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newNode); /* For creating Targetvariables */ - UA_FieldTargetDataType_init(&targetVars[i].targetVariable); - targetVars[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars[i].targetVariable.targetNodeId = newNode; + targetVars[i].attributeId = UA_ATTRIBUTEID_VALUE; + targetVars[i].targetNodeId = newNode; } UA_Server_DataSetReader_createTargetVariables(server, dataSetReaderId, readerConfig.dataSetMetaData.fieldsSize, targetVars); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); + UA_FieldTargetDataType_clear(&targetVars[i]); UA_free(targetVars); UA_free(readerConfig.dataSetMetaData.fields); diff --git a/examples/pubsub/sks/pubsub_subscribe_encrypted_sks.c b/examples/pubsub/sks/pubsub_subscribe_encrypted_sks.c index e1292246a..05a9e36eb 100644 --- a/examples/pubsub/sks/pubsub_subscribe_encrypted_sks.c +++ b/examples/pubsub/sks/pubsub_subscribe_encrypted_sks.c @@ -141,9 +141,9 @@ addSubscribedVariables(UA_Server *server, UA_NodeId dataSetReaderId) { * between received DataSet fields and target Variables in the Subscriber * AddressSpace. The values subscribed from the Publisher are updated in the value * field of these variables */ - /* Create the TargetVariables with respect to DataSetMetaData fields */ - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *)UA_calloc( - readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -160,16 +160,12 @@ addSubscribedVariables(UA_Server *server, UA_NodeId dataSetReaderId) { UA_QUALIFIEDNAME(1, (char *)readerConfig.dataSetMetaData.fields[i].name.data), UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newNode); - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(&targetVars[i].targetVariable); - targetVars[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars[i].targetVariable.targetNodeId = newNode; + targetVars[i].attributeId = UA_ATTRIBUTEID_VALUE; + targetVars[i].targetNodeId = newNode; } UA_Server_DataSetReader_createTargetVariables(server, dataSetReaderId, readerConfig.dataSetMetaData.fieldsSize, targetVars); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); UA_free(targetVars); UA_free(readerConfig.dataSetMetaData.fields); diff --git a/examples/pubsub/tutorial_pubsub_mqtt_subscribe.c b/examples/pubsub/tutorial_pubsub_mqtt_subscribe.c index ba11912a5..2051372f4 100644 --- a/examples/pubsub/tutorial_pubsub_mqtt_subscribe.c +++ b/examples/pubsub/tutorial_pubsub_mqtt_subscribe.c @@ -215,8 +215,8 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { * received DataSet fields and target Variables in the Subscriber AddressSpace. * The values subscribed from the Publisher are updated in the value field of these variables */ /* Create the TargetVariables with respect to DataSetMetaData fields */ - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType *) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -233,17 +233,13 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newNode); - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(&targetVars[i].targetVariable); - targetVars[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars[i].targetVariable.targetNodeId = newNode; + targetVars[i].attributeId = UA_ATTRIBUTEID_VALUE; + targetVars[i].targetNodeId = newNode; } UA_Server_DataSetReader_createTargetVariables(server, dataSetReaderId, readerConfig.dataSetMetaData.fieldsSize, targetVars); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); UA_free(targetVars); UA_free(readerConfig.dataSetMetaData.fields); diff --git a/examples/pubsub/tutorial_pubsub_subscribe.c b/examples/pubsub/tutorial_pubsub_subscribe.c index 56bbd03b9..14986bda1 100644 --- a/examples/pubsub/tutorial_pubsub_subscribe.c +++ b/examples/pubsub/tutorial_pubsub_subscribe.c @@ -117,15 +117,17 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { UA_NS0ID(OBJECTSFOLDER), UA_NS0ID(ORGANIZES), folderBrowseName, UA_NS0ID(BASEOBJECTTYPE), oAttr, NULL, &folderId); -/** - * **TargetVariables** - * - * The SubscribedDataSet option TargetVariables defines a list of Variable mappings between - * received DataSet fields and target Variables in the Subscriber AddressSpace. - * The values subscribed from the Publisher are updated in the value field of these variables */ + /** + * **TargetVariables** + * + * The SubscribedDataSet option TargetVariables defines a list of Variable + * mappings between received DataSet fields and target Variables in the + * Subscriber AddressSpace. The values subscribed from the Publisher are + * updated in the value field of these variables */ + /* Create the TargetVariables with respect to DataSetMetaData fields */ - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType *) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -143,16 +145,13 @@ addSubscribedVariables (UA_Server *server, UA_NodeId dataSetReaderId) { vAttr, NULL, &newNode); /* For creating Targetvariables */ - UA_FieldTargetDataType_init(&targetVars[i].targetVariable); - targetVars[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars[i].targetVariable.targetNodeId = newNode; + targetVars[i].attributeId = UA_ATTRIBUTEID_VALUE; + targetVars[i].targetNodeId = newNode; } UA_Server_DataSetReader_createTargetVariables(server, dataSetReaderId, readerConfig.dataSetMetaData.fieldsSize, targetVars); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); UA_free(targetVars); UA_free(readerConfig.dataSetMetaData.fields); diff --git a/examples/pubsub_realtime/server_pubsub_publish_rt_offsets.c b/examples/pubsub_realtime/server_pubsub_publish_rt_offsets.c index 5eefbf503..92bf5cb03 100644 --- a/examples/pubsub_realtime/server_pubsub_publish_rt_offsets.c +++ b/examples/pubsub_realtime/server_pubsub_publish_rt_offsets.c @@ -74,8 +74,6 @@ int main(void) { /* Add the DataSetField */ memset(&dsfConfig, 0, sizeof(UA_DataSetFieldConfig)); dsfConfig.field.variable.publishParameters.publishedVariable = publishVariables[i]; - dsfConfig.field.variable.rtValueSource.rtFieldSourceEnabled = true; - dsfConfig.field.variable.rtValueSource.staticValueSource = &dvPointers[i]; UA_Server_addDataSetField(server, publishedDataSetIdent, &dsfConfig, &dataSetFieldIdent); } diff --git a/examples/pubsub_realtime/server_pubsub_publish_rt_state_machine.c b/examples/pubsub_realtime/server_pubsub_publish_rt_state_machine.c index c78d52353..01c9ec7db 100644 --- a/examples/pubsub_realtime/server_pubsub_publish_rt_state_machine.c +++ b/examples/pubsub_realtime/server_pubsub_publish_rt_state_machine.c @@ -154,8 +154,6 @@ int main(void) { for(size_t i = 0; i < PUBSUB_CONFIG_FIELD_COUNT; i++) { /* TODO: Point to a variable in the information model */ memset(&dsfConfig, 0, sizeof(UA_DataSetFieldConfig)); - dsfConfig.field.variable.rtValueSource.rtFieldSourceEnabled = true; - dsfConfig.field.variable.rtValueSource.staticValueSource = &dvPointers[i]; UA_Server_addDataSetField(server, publishedDataSetIdent, &dsfConfig, &dataSetFieldIdent); } diff --git a/examples/pubsub_realtime/server_pubsub_subscribe_rt_offsets.c b/examples/pubsub_realtime/server_pubsub_subscribe_rt_offsets.c index 5cbfbcbea..9d39072ce 100644 --- a/examples/pubsub_realtime/server_pubsub_subscribe_rt_offsets.c +++ b/examples/pubsub_realtime/server_pubsub_subscribe_rt_offsets.c @@ -27,17 +27,9 @@ static UA_String transportProfile = * the buffered NetworkMessage will only be updated. */ -UA_NodeId connectionIdentifier; -UA_NodeId readerGroupIdentifier; -UA_NodeId readerIdentifier; - UA_Server *server; - UA_DataSetReaderConfig readerConfig; - -/* Simulate a custom data sink (e.g. shared memory) */ -UA_UInt32 repeatedFieldValues[PUBSUB_CONFIG_FIELD_COUNT]; -UA_DataValue *repeatedDataValueRT[PUBSUB_CONFIG_FIELD_COUNT]; +UA_NodeId connectionIdentifier, readerGroupIdentifier, readerIdentifier; /* Define MetaData for TargetVariables */ static void @@ -117,12 +109,11 @@ addSubscribedVariables (UA_Server *server) { /* Set the subscribed data to TargetVariable type */ readerConfig.subscribedDataSetType = UA_PUBSUB_SDS_TARGET; /* Create the TargetVariables with respect to DataSetMetaData fields */ - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize = + readerConfig.subscribedDataSet.target.targetVariablesSize = readerConfig.dataSetMetaData.fieldsSize; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables = - (UA_FieldTargetVariable *)UA_calloc( - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize, - sizeof(UA_FieldTargetVariable)); + readerConfig.subscribedDataSet.target.targetVariables = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.subscribedDataSet.target.targetVariablesSize, + sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -141,28 +132,10 @@ addSubscribedVariables (UA_Server *server) { UA_QUALIFIEDNAME(1, "Subscribed UInt32"), UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); - repeatedFieldValues[i] = 0; - repeatedDataValueRT[i] = UA_DataValue_new(); - UA_Variant_setScalar(&repeatedDataValueRT[i]->value, &repeatedFieldValues[i], - &UA_TYPES[UA_TYPES_UINT32]); - repeatedDataValueRT[i]->value.storageType = UA_VARIANT_DATA_NODELETE; - repeatedDataValueRT[i]->hasValue = true; - /* Set the value backend of the above create node to 'external value source' */ - UA_ValueBackend valueBackend; - memset(&valueBackend, 0, sizeof(UA_ValueBackend)); - valueBackend.backendType = UA_VALUEBACKENDTYPE_EXTERNAL; - valueBackend.backend.external.value = &repeatedDataValueRT[i]; - UA_Server_setVariableNode_valueBackend(server, newnodeId, valueBackend); - - UA_FieldTargetVariable *tv = - &readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; - UA_FieldTargetDataType *ftdt = &tv->targetVariable; - - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(ftdt); - ftdt->attributeId = UA_ATTRIBUTEID_VALUE; - ftdt->targetNodeId = newnodeId; + UA_FieldTargetDataType *tv = &readerConfig.subscribedDataSet.target.targetVariables[i]; + tv->attributeId = UA_ATTRIBUTEID_VALUE; + tv->targetNodeId = newnodeId; } } @@ -200,14 +173,7 @@ addDataSetReader(UA_Server *server) { addSubscribedVariables(server); UA_Server_addDataSetReader(server, readerGroupIdentifier, &readerConfig, &readerIdentifier); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { - UA_FieldTargetVariable *tv = - &readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; - UA_FieldTargetDataType *ftdt = &tv->targetVariable; - UA_FieldTargetDataType_clear(ftdt); - } - - UA_free(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables); + UA_DataSetReaderConfig_clear(&readerConfig); UA_free(readerConfig.dataSetMetaData.fields); UA_UadpDataSetReaderMessageDataType_delete(dataSetReaderMessage); } @@ -258,12 +224,7 @@ int main(int argc, char **argv) { } UA_Server_delete(server); - UA_PubSubOffsetTable_clear(&ot); - for(UA_Int32 i = 0; i < PUBSUB_CONFIG_FIELD_COUNT; i++) { - UA_DataValue_delete(repeatedDataValueRT[i]); - } return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE; } - diff --git a/examples/pubsub_realtime/server_pubsub_subscribe_rt_state_machine.c b/examples/pubsub_realtime/server_pubsub_subscribe_rt_state_machine.c index c6ffa590e..0793e3995 100644 --- a/examples/pubsub_realtime/server_pubsub_subscribe_rt_state_machine.c +++ b/examples/pubsub_realtime/server_pubsub_subscribe_rt_state_machine.c @@ -208,78 +208,6 @@ connectionStateMachine(UA_Server *server, const UA_NodeId componentId, return UA_STATUSCODE_GOOD; } -/* Simulate a custom data sink (e.g. shared memory) */ -UA_UInt32 repeatedFieldValues[PUBSUB_CONFIG_FIELD_COUNT]; -UA_DataValue *repeatedDataValueRT[PUBSUB_CONFIG_FIELD_COUNT]; - -/* If the external data source is written over the information model, the - * externalDataWriteCallback will be triggered. The user has to take care and assure - * that the write leads not to synchronization issues and race conditions. */ -static UA_StatusCode -externalDataWriteCallback(UA_Server *server, const UA_NodeId *sessionId, - void *sessionContext, const UA_NodeId *nodeId, - void *nodeContext, const UA_NumericRange *range, - const UA_DataValue *data){ - //node values are updated by using variables in the memory - //UA_Server_write is not used for updating node values. - return UA_STATUSCODE_GOOD; -} - -static UA_StatusCode -externalDataReadNotificationCallback(UA_Server *server, const UA_NodeId *sessionId, - void *sessionContext, const UA_NodeId *nodeid, - void *nodeContext, const UA_NumericRange *range){ - //allow read without any preparation - return UA_STATUSCODE_GOOD; -} - -static void -subscribeAfterWriteCallback(UA_Server *server, const UA_NodeId *dataSetReaderId, - const UA_NodeId *readerGroupId, - const UA_NodeId *targetVariableId, - void *targetVariableContext, - UA_DataValue **externalDataValue) { - (void) server; - (void) dataSetReaderId; - (void) readerGroupId; - (void) targetVariableContext; - - assert(targetVariableId != 0); - assert(externalDataValue != 0); - - UA_String strId; - UA_String_init(&strId); - UA_NodeId_print(targetVariableId, &strId); - UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "subscribeAfterWriteCallback(): " - "WriteUpdate() for node Id = '%.*s'. New Value = %u", (UA_Int32) strId.length, strId.data, - *((UA_UInt32*) (**externalDataValue).value.data)); - UA_String_clear(&strId); -} - -/* Callback gets triggered before subscriber has received data received data - * hasn't been copied/handled yet */ -static void -subscribeBeforeWriteCallback(UA_Server *server, const UA_NodeId *dataSetReaderId, - const UA_NodeId *readerGroupId, const UA_NodeId *targetVariableId, - void *targetVariableContext, UA_DataValue **externalDataValue) { - (void) server; - (void) dataSetReaderId; - (void) readerGroupId; - (void) targetVariableContext; - - assert(targetVariableId != 0); - assert(externalDataValue != 0); - - UA_String strId; - UA_String_init(&strId); - UA_NodeId_print(targetVariableId, &strId); - UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, - "subscribeBeforeWriteCallback(): " - "WriteUpdate() for node Id = '%.*s'", - (UA_Int32) strId.length, strId.data); - UA_String_clear(&strId); -} - /* Define MetaData for TargetVariables */ static void fillTestDataSetMetaData(UA_DataSetMetaDataType *pMetaData) { @@ -359,12 +287,11 @@ addSubscribedVariables (UA_Server *server) { /* Set the subscribed data to TargetVariable type */ readerConfig.subscribedDataSetType = UA_PUBSUB_SDS_TARGET; /* Create the TargetVariables with respect to DataSetMetaData fields */ - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize = + readerConfig.subscribedDataSet.target.targetVariablesSize = readerConfig.dataSetMetaData.fieldsSize; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables = - (UA_FieldTargetVariable *)UA_calloc( - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize, - sizeof(UA_FieldTargetVariable)); + readerConfig.subscribedDataSet.target.targetVariables = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.subscribedDataSet.target.targetVariablesSize, + sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -383,33 +310,11 @@ addSubscribedVariables (UA_Server *server) { UA_QUALIFIEDNAME(1, "Subscribed UInt32"), UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); - repeatedFieldValues[i] = 0; - repeatedDataValueRT[i] = UA_DataValue_new(); - UA_Variant_setScalar(&repeatedDataValueRT[i]->value, &repeatedFieldValues[i], - &UA_TYPES[UA_TYPES_UINT32]); - repeatedDataValueRT[i]->value.storageType = UA_VARIANT_DATA_NODELETE; - repeatedDataValueRT[i]->hasValue = true; - /* Set the value backend of the above create node to 'external value source' */ - UA_ValueBackend valueBackend; - valueBackend.backendType = UA_VALUEBACKENDTYPE_EXTERNAL; - valueBackend.backend.external.value = &repeatedDataValueRT[i]; - valueBackend.backend.external.callback.userWrite = externalDataWriteCallback; - valueBackend.backend.external.callback.notificationRead = externalDataReadNotificationCallback; - UA_Server_setVariableNode_valueBackend(server, newnodeId, valueBackend); - - UA_FieldTargetVariable *tv = - &readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; - UA_FieldTargetDataType *ftdt = &tv->targetVariable; - - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(ftdt); - ftdt->attributeId = UA_ATTRIBUTEID_VALUE; - ftdt->targetNodeId = newnodeId; - /* set both before and after write callback to show the usage */ - tv->beforeWrite = subscribeBeforeWriteCallback; - tv->externalDataValue = &repeatedDataValueRT[i]; - tv->afterWrite = subscribeAfterWriteCallback; + UA_FieldTargetDataType *tv = + &readerConfig.subscribedDataSet.target.targetVariables[i]; + tv->attributeId = UA_ATTRIBUTEID_VALUE; + tv->targetNodeId = newnodeId; } } @@ -430,8 +335,10 @@ addDataSetReader(UA_Server *server) { readerConfig.dataSetWriterId = 62541; readerConfig.messageSettings.encoding = UA_EXTENSIONOBJECT_DECODED; readerConfig.expectedEncoding = UA_PUBSUB_RT_RAW; - readerConfig.messageSettings.content.decoded.type = &UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]; - UA_UadpDataSetReaderMessageDataType *dataSetReaderMessage = UA_UadpDataSetReaderMessageDataType_new(); + readerConfig.messageSettings.content.decoded.type = + &UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]; + UA_UadpDataSetReaderMessageDataType *dataSetReaderMessage = + UA_UadpDataSetReaderMessageDataType_new(); dataSetReaderMessage->networkMessageContentMask = (UA_UadpNetworkMessageContentMask) (UA_UADPNETWORKMESSAGECONTENTMASK_PUBLISHERID | UA_UADPNETWORKMESSAGECONTENTMASK_GROUPHEADER | UA_UADPNETWORKMESSAGECONTENTMASK_SEQUENCENUMBER | UA_UADPNETWORKMESSAGECONTENTMASK_WRITERGROUPID | @@ -447,15 +354,7 @@ addDataSetReader(UA_Server *server) { addSubscribedVariables(server); UA_Server_addDataSetReader(server, readerGroupIdentifier, &readerConfig, &readerIdentifier); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { - UA_FieldTargetVariable *tv = - &readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; - UA_FieldTargetDataType *ftdt = &tv->targetVariable; - UA_FieldTargetDataType_clear(ftdt); - } - - UA_free(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables); - UA_free(readerConfig.dataSetMetaData.fields); + UA_DataSetReaderConfig_clear(&readerConfig); UA_UadpDataSetReaderMessageDataType_delete(dataSetReaderMessage); } @@ -495,12 +394,6 @@ int main(int argc, char **argv) { retval = UA_Server_runUntilInterrupt(server); UA_Server_delete(server); - pthread_join(listenThread, NULL); - - for(UA_Int32 i = 0; i < PUBSUB_CONFIG_FIELD_COUNT; i++) { - UA_DataValue_delete(repeatedDataValueRT[i]); - } - return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/include/open62541/server_pubsub.h b/include/open62541/server_pubsub.h index a5ca20e2d..1f96db6be 100644 --- a/include/open62541/server_pubsub.h +++ b/include/open62541/server_pubsub.h @@ -376,20 +376,10 @@ typedef struct { UA_Boolean promotedField; UA_PublishedVariableDataType publishParameters; - /* non std. field */ - struct { - UA_Boolean rtFieldSourceEnabled; - /* If the rtInformationModelNode is set, the nodeid in publishParameter - * must point to a node with external data source backend defined */ - UA_Boolean rtInformationModelNode; - /* TODO: Decide if suppress C++ warnings and use 'UA_DataValue * * const - * staticValueSource;' */ - UA_DataValue ** staticValueSource; - } rtValueSource; UA_UInt32 maxStringLength; UA_LocalizedText description; /* If dataSetFieldId is not set, the GUID will be generated on adding the - * field*/ + * field */ UA_Guid dataSetFieldId; } UA_DataSetVariableConfig; @@ -630,42 +620,11 @@ typedef enum { UA_PUBSUB_SDS_MIRROR } UA_SubscribedDataSetType; -typedef struct { - /* Standard-defined FieldTargetDataType */ - UA_FieldTargetDataType targetVariable; - - /* If realtime-handling is required, set this pointer non-NULL and it will be used - * to memcpy the value instead of using the Write service. - * If the beforeWrite method pointer is set, it will be called before a memcpy update - * to the value. But param externalDataValue already contains the new value. - * If the afterWrite method pointer is set, it will be called after a memcpy update - * to the value. */ - UA_DataValue **externalDataValue; - void *targetVariableContext; /* user-defined pointer */ - void (*beforeWrite)(UA_Server *server, - const UA_NodeId *readerIdentifier, - const UA_NodeId *readerGroupIdentifier, - const UA_NodeId *targetVariableIdentifier, - void *targetVariableContext, - UA_DataValue **externalDataValue); - void (*afterWrite)(UA_Server *server, - const UA_NodeId *readerIdentifier, - const UA_NodeId *readerGroupIdentifier, - const UA_NodeId *targetVariableIdentifier, - void *targetVariableContext, - UA_DataValue **externalDataValue); -} UA_FieldTargetVariable; - -typedef struct { - size_t targetVariablesSize; - UA_FieldTargetVariable *targetVariables; -} UA_TargetVariables; - typedef struct { UA_String name; UA_SubscribedDataSetType subscribedDataSetType; union { - /* datasetmirror is currently not implemented */ + /* DataSetMirror is currently not implemented */ UA_TargetVariablesDataType target; } subscribedDataSet; UA_DataSetMetaDataType dataSetMetaData; @@ -719,10 +678,9 @@ typedef struct { UA_ExtensionObject messageSettings; UA_ExtensionObject transportSettings; UA_SubscribedDataSetType subscribedDataSetType; - /* TODO UA_SubscribedDataSetMirrorDataType subscribedDataSetMirror */ union { - UA_TargetVariables subscribedDataSetTarget; - // UA_SubscribedDataSetMirrorDataType subscribedDataSetMirror; + /* TODO: UA_SubscribedDataSetMirrorDataType subscribedDataSetMirror */ + UA_TargetVariablesDataType target; } subscribedDataSet; /* non std. fields */ UA_String linkedStandaloneSubscribedDataSetName; @@ -763,10 +721,8 @@ UA_EXPORT UA_StatusCode UA_THREADSAFE UA_Server_disableDataSetReader(UA_Server *server, const UA_NodeId dsrId); UA_EXPORT UA_StatusCode UA_THREADSAFE -UA_Server_setDataSetReaderTargetVariables(UA_Server *server, - const UA_NodeId dsrId, - size_t tvsSize, - const UA_FieldTargetVariable *tvs); +UA_Server_setDataSetReaderTargetVariables(UA_Server *server, const UA_NodeId dsrId, + size_t targetVariablesSize, const UA_FieldTargetDataType *targetVariables); /* Legacy API */ #define UA_Server_DataSetReader_getConfig(server, dsrId, config) \ @@ -786,13 +742,7 @@ UA_Server_setDataSetReaderTargetVariables(UA_Server *server, * DataSetReader. * * The RT-levels go along with different requirements. The below listed levels - * can be configured for a ReaderGroup. - * - * - UA_PUBSUB_RT_NONE: RT applied to this level - * - UA_PUBSUB_RT_FIXED_SIZE: Extends PubSub RT functionality and implements - * fast path message decoding in the Subscriber. Uses a buffered network - * message and only decodes the necessary offsets stored in an offset - * buffer. */ + * can be configured for a ReaderGroup. */ typedef struct { UA_String name; diff --git a/src/pubsub/ua_pubsub_config.c b/src/pubsub/ua_pubsub_config.c index 39cc8f94f..ead4d0bd4 100644 --- a/src/pubsub/ua_pubsub_config.c +++ b/src/pubsub/ua_pubsub_config.c @@ -517,33 +517,19 @@ addSubscribedDataSet(UA_PubSubManager *psm, const UA_NodeId dsReaderIdent, if(subscribedDataSet->content.decoded.type == &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]) { - UA_TargetVariablesDataType *tmpTargetVars = (UA_TargetVariablesDataType*) + UA_TargetVariablesDataType *targetVars = (UA_TargetVariablesDataType*) subscribedDataSet->content.decoded.data; - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(tmpTargetVars->targetVariablesSize, sizeof(UA_FieldTargetVariable)); - - for(size_t index = 0; index < tmpTargetVars->targetVariablesSize; index++) { - UA_FieldTargetDataType_copy(&tmpTargetVars->targetVariables[index], - &targetVars[index].targetVariable); - } - UA_StatusCode res = UA_STATUSCODE_BADINTERNALERROR; UA_DataSetReader *dsr = UA_DataSetReader_find(psm, dsReaderIdent); if(dsr) res = DataSetReader_createTargetVariables(psm, dsr, - tmpTargetVars->targetVariablesSize, - targetVars); + targetVars->targetVariablesSize, + targetVars->targetVariables); if(res != UA_STATUSCODE_GOOD) { UA_LOG_ERROR(psm->logging, UA_LOGCATEGORY_PUBSUB, "[UA_PubSubManager_addSubscribedDataSet] " "create TargetVariables failed"); } - - for(size_t index = 0; index < tmpTargetVars->targetVariablesSize; index++) { - UA_FieldTargetDataType_clear(&targetVars[index].targetVariable); - } - - UA_free(targetVars); return res; } @@ -989,22 +975,21 @@ generateDataSetReaderDataType(const UA_DataSetReader *src, UA_TargetVariablesDataType *tmpTarget = UA_TargetVariablesDataType_new(); if(!tmpTarget) return UA_STATUSCODE_BADOUTOFMEMORY; - UA_ExtensionObject_setValue(&dst->subscribedDataSet, tmpTarget, - &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]); - const UA_TargetVariables *targets = - &src->config.subscribedDataSet.subscribedDataSetTarget; + const UA_TargetVariablesDataType *targets = &src->config.subscribedDataSet.target; tmpTarget->targetVariables = (UA_FieldTargetDataType *) UA_calloc(targets->targetVariablesSize, sizeof(UA_FieldTargetDataType)); if(!tmpTarget->targetVariables) return UA_STATUSCODE_BADOUTOFMEMORY; tmpTarget->targetVariablesSize = targets->targetVariablesSize; - for(size_t i = 0; i < tmpTarget->targetVariablesSize; i++) { - res |= UA_FieldTargetDataType_copy(&targets->targetVariables[i].targetVariable, + res |= UA_FieldTargetDataType_copy(&targets->targetVariables[i], &tmpTarget->targetVariables[i]); } + UA_ExtensionObject_setValue(&dst->subscribedDataSet, tmpTarget, + &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]); + return res; } diff --git a/src/pubsub/ua_pubsub_dataset.c b/src/pubsub/ua_pubsub_dataset.c index 2269fa962..e39faf1fe 100644 --- a/src/pubsub/ua_pubsub_dataset.c +++ b/src/pubsub/ua_pubsub_dataset.c @@ -121,12 +121,9 @@ generateFieldMetaData(UA_PubSubManager *psm, UA_PublishedDataSet *pds, const UA_DataSetVariableConfig *var = &field->config.field.variable; /* Set the field identifier */ - if(!UA_Guid_equal(&var->dataSetFieldId, &UA_GUID_NULL)) - { + if(!UA_Guid_equal(&var->dataSetFieldId, &UA_GUID_NULL)) { fieldMetaData->dataSetFieldId = var->dataSetFieldId; - } - else - { + } else { fieldMetaData->dataSetFieldId = UA_PubSubManager_generateUniqueGuid(psm); } @@ -137,32 +134,6 @@ generateFieldMetaData(UA_PubSubManager *psm, UA_PublishedDataSet *pds, UA_StatusCode res = UA_String_copy(&var->fieldNameAlias, &fieldMetaData->name); UA_CHECK_STATUS(res, return res); - /* Static value source. ToDo after freeze PR, the value source must be - * checked (other behavior for static value source) */ - if(var->rtValueSource.rtFieldSourceEnabled && - !var->rtValueSource.rtInformationModelNode) { - const UA_DataValue *svs = *var->rtValueSource.staticValueSource; - if(svs->value.arrayDimensionsSize > 0) { - fieldMetaData->arrayDimensions = (UA_UInt32 *) - UA_calloc(svs->value.arrayDimensionsSize, sizeof(UA_UInt32)); - if(fieldMetaData->arrayDimensions == NULL) - return UA_STATUSCODE_BADOUTOFMEMORY; - memcpy(fieldMetaData->arrayDimensions, svs->value.arrayDimensions, - sizeof(UA_UInt32) * svs->value.arrayDimensionsSize); - } - fieldMetaData->arrayDimensionsSize = svs->value.arrayDimensionsSize; - - if(svs->value.type) - res = UA_NodeId_copy(&svs->value.type->typeId, &fieldMetaData->dataType); - UA_CHECK_STATUS(res, return res); - - //TODO collect value rank for the static field source - fieldMetaData->properties = NULL; - fieldMetaData->propertiesSize = 0; - fieldMetaData->fieldFlags = UA_DATASETFIELDFLAGS_NONE; - return UA_STATUSCODE_GOOD; - } - /* Set the Array Dimensions */ const UA_PublishedVariableDataType *pp = &var->publishParameters; UA_Variant value; @@ -180,8 +151,6 @@ generateFieldMetaData(UA_PubSubManager *psm, UA_PublishedDataSet *pds, UA_calloc(value.arrayDimensionsSize, sizeof(UA_UInt32)); if(!fieldMetaData->arrayDimensions) return UA_STATUSCODE_BADOUTOFMEMORY; - memcpy(fieldMetaData->arrayDimensions, value.arrayDimensions, - sizeof(UA_UInt32)*value.arrayDimensionsSize); } fieldMetaData->arrayDimensionsSize = value.arrayDimensionsSize; @@ -496,25 +465,13 @@ UA_PubSubDataSetField_sampleValue(UA_PubSubManager *psm, UA_DataSetField *field, UA_DataValue *value) { UA_PublishedVariableDataType *params = &field->config.field.variable.publishParameters; - /* Read the value */ - if(field->config.field.variable.rtValueSource.rtInformationModelNode) { - const UA_VariableNode *rtNode = (const UA_VariableNode *) - UA_NODESTORE_GET(psm->sc.server, ¶ms->publishedVariable); - *value = **rtNode->valueBackend.backend.external.value; - value->value.storageType = UA_VARIANT_DATA_NODELETE; - UA_NODESTORE_RELEASE(psm->sc.server, (const UA_Node *) rtNode); - } else if(field->config.field.variable.rtValueSource.rtFieldSourceEnabled == false){ - UA_ReadValueId rvid; - UA_ReadValueId_init(&rvid); - rvid.nodeId = params->publishedVariable; - rvid.attributeId = params->attributeId; - rvid.indexRange = params->indexRange; - *value = readWithSession(psm->sc.server, &psm->sc.server->adminSession, - &rvid, UA_TIMESTAMPSTORETURN_BOTH); - } else { - *value = **field->config.field.variable.rtValueSource.staticValueSource; - value->value.storageType = UA_VARIANT_DATA_NODELETE; - } + UA_ReadValueId rvid; + UA_ReadValueId_init(&rvid); + rvid.nodeId = params->publishedVariable; + rvid.attributeId = params->attributeId; + rvid.indexRange = params->indexRange; + *value = readWithSession(psm->sc.server, &psm->sc.server->adminSession, + &rvid, UA_TIMESTAMPSTORETURN_BOTH); } UA_AddPublishedDataSetResult @@ -731,9 +688,10 @@ UA_SubscribedDataSetConfig_copy(const UA_SubscribedDataSetConfig *src, memcpy(dst, src, sizeof(UA_SubscribedDataSetConfig)); res = UA_DataSetMetaDataType_copy(&src->dataSetMetaData, &dst->dataSetMetaData); res |= UA_String_copy(&src->name, &dst->name); - res |= UA_TargetVariablesDataType_copy(&src->subscribedDataSet.target, - &dst->subscribedDataSet.target); - + if(src->subscribedDataSetType == UA_PUBSUB_SDS_TARGET) { + res |= UA_TargetVariablesDataType_copy(&src->subscribedDataSet.target, + &dst->subscribedDataSet.target); + } if(res != UA_STATUSCODE_GOOD) UA_SubscribedDataSetConfig_clear(dst); return res; diff --git a/src/pubsub/ua_pubsub_internal.h b/src/pubsub/ua_pubsub_internal.h index 48d9e7a88..0bd32b4a9 100644 --- a/src/pubsub/ua_pubsub_internal.h +++ b/src/pubsub/ua_pubsub_internal.h @@ -495,27 +495,14 @@ UA_DataSetReader_create(UA_PubSubManager *psm, UA_NodeId readerGroupIdentifier, UA_StatusCode UA_DataSetReader_remove(UA_PubSubManager *psm, UA_DataSetReader *dsr); -/* Copy the configuration of Target Variables */ -UA_StatusCode UA_TargetVariables_copy(const UA_TargetVariables *src, - UA_TargetVariables *dst); - -/* Clear the Target Variables configuration */ -void UA_TargetVariables_clear(UA_TargetVariables *subscribedDataSetTarget); - -/* Copy the configuration of Field Target Variables */ -UA_StatusCode UA_FieldTargetVariable_copy(const UA_FieldTargetVariable *src, - UA_FieldTargetVariable *dst); - UA_StatusCode DataSetReader_createTargetVariables(UA_PubSubManager *psm, UA_DataSetReader *dsr, - size_t targetVariablesSize, - const UA_FieldTargetVariable *targetVariables); + size_t targetsSize, const UA_FieldTargetDataType *targets); /* Returns an error reason if the target state is `Error` */ void UA_DataSetReader_setPubSubState(UA_PubSubManager *psm, UA_DataSetReader *dsr, - UA_PubSubState targetState, - UA_StatusCode errorReason); + UA_PubSubState targetState, UA_StatusCode errorReason); /**********************************************/ /* ReaderGroup */ diff --git a/src/pubsub/ua_pubsub_ns0.c b/src/pubsub/ua_pubsub_ns0.c index 1b012b8b2..837c69a6a 100644 --- a/src/pubsub/ua_pubsub_ns0.c +++ b/src/pubsub/ua_pubsub_ns0.c @@ -522,7 +522,6 @@ addSubscribedVariables(UA_Server *server, UA_NodeId dataSetReaderId, if(!psm) return UA_STATUSCODE_BADINTERNALERROR; - UA_StatusCode retVal = UA_STATUSCODE_GOOD; UA_ExtensionObject *eoTargetVar = &dataSetReader->subscribedDataSet; if(eoTargetVar->encoding != UA_EXTENSIONOBJECT_DECODED || eoTargetVar->content.decoded.type != &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]) @@ -531,6 +530,10 @@ addSubscribedVariables(UA_Server *server, UA_NodeId dataSetReaderId, const UA_TargetVariablesDataType *targetVars = (UA_TargetVariablesDataType*)eoTargetVar->content.decoded.data; + UA_DataSetReader *dsr = UA_DataSetReader_find(psm, dataSetReaderId); + if(!dsr) + return UA_STATUSCODE_BADINTERNALERROR; + UA_NodeId folderId; UA_String folderName = pMetaData->name; UA_ObjectAttributes oAttr = UA_ObjectAttributes_default; @@ -556,40 +559,25 @@ addSubscribedVariables(UA_Server *server, UA_NodeId dataSetReaderId, * Subscriber AddressSpace. The values subscribed from the Publisher are * updated in the value field of these variables */ - /* Create the TargetVariables with respect to DataSetMetaData fields */ - UA_FieldTargetVariable *targetVarsData = (UA_FieldTargetVariable *) - UA_calloc(targetVars->targetVariablesSize, sizeof(UA_FieldTargetVariable)); + /* Add variable for the fields */ for(size_t i = 0; i < targetVars->targetVariablesSize; i++) { - /* Prepare the output structure */ - UA_FieldTargetDataType_init(&targetVarsData[i].targetVariable); - targetVarsData[i].targetVariable.attributeId = targetVars->targetVariables[i].attributeId; - - /* Add variable for the field */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; vAttr.description = pMetaData->fields[i].description; vAttr.displayName.locale = UA_STRING(""); vAttr.displayName.text = pMetaData->fields[i].name; vAttr.dataType = pMetaData->fields[i].dataType; UA_QualifiedName varname = {1, pMetaData->fields[i].name}; - retVal |= addNode(server, UA_NODECLASS_VARIABLE, - targetVars->targetVariables[i].targetNodeId, folderId, - UA_NS0ID(HASCOMPONENT), varname, UA_NS0ID(BASEDATAVARIABLETYPE), - &vAttr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES], - NULL, &targetVarsData[i].targetVariable.targetNodeId); + addNode(server, UA_NODECLASS_VARIABLE, + targetVars->targetVariables[i].targetNodeId, folderId, + UA_NS0ID(HASCOMPONENT), varname, UA_NS0ID(BASEDATAVARIABLETYPE), + &vAttr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES], + NULL, &targetVars->targetVariables[i].targetNodeId); + } - } - UA_DataSetReader *dsr = UA_DataSetReader_find(psm, dataSetReaderId); - if(dsr) { - retVal = DataSetReader_createTargetVariables(psm, dsr, - targetVars->targetVariablesSize, - targetVarsData); - } else { - retVal = UA_STATUSCODE_BADINTERNALERROR; - } - for(size_t j = 0; j < targetVars->targetVariablesSize; j++) - UA_FieldTargetDataType_clear(&targetVarsData[j].targetVariable); - UA_free(targetVarsData); - return retVal; + /* Set the TargetVariables in the DSR config */ + return DataSetReader_createTargetVariables(psm, dsr, + targetVars->targetVariablesSize, + targetVars->targetVariables); } /** diff --git a/src/pubsub/ua_pubsub_reader.c b/src/pubsub/ua_pubsub_reader.c index 982f118ab..18b9a0509 100644 --- a/src/pubsub/ua_pubsub_reader.c +++ b/src/pubsub/ua_pubsub_reader.c @@ -205,25 +205,12 @@ UA_DataSetReader_create(UA_PubSubManager *psm, UA_NodeId readerGroupIdentifier, &dsr->config.dataSetMetaData); /* Prepare the input for _createTargetVariables and call it */ - UA_TargetVariablesDataType *tvs = &sds->config.subscribedDataSet.target; - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(tvs->targetVariablesSize, sizeof(UA_FieldTargetVariable)); - for(size_t i = 0; i < tvs->targetVariablesSize; i++) { - UA_FieldTargetDataType_copy(&tvs->targetVariables[i], - &targetVars[i].targetVariable); - } - + UA_TargetVariablesDataType *tvs = + &sds->config.subscribedDataSet.target; DataSetReader_createTargetVariables(psm, dsr, tvs->targetVariablesSize, - targetVars); + tvs->targetVariables); - /* Clean up the temporary array */ - for(size_t i = 0; i < tvs->targetVariablesSize; i++) { - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); - } - UA_free(targetVars); - - /* Set the backpointer */ - sds->connectedReader = dsr; + sds->connectedReader = dsr; /* Set the backpointer */ /* Make the connection visible in the information model */ #ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL @@ -325,8 +312,8 @@ UA_DataSetReaderConfig_copy(const UA_DataSetReaderConfig *src, &dst->linkedStandaloneSubscribedDataSetName); if(src->subscribedDataSetType == UA_PUBSUB_SDS_TARGET) { - ret |= UA_TargetVariables_copy(&src->subscribedDataSet.subscribedDataSetTarget, - &dst->subscribedDataSet.subscribedDataSetTarget); + ret |= UA_TargetVariablesDataType_copy(&src->subscribedDataSet.target, + &dst->subscribedDataSet.target); } if(ret != UA_STATUSCODE_GOOD) @@ -344,7 +331,7 @@ UA_DataSetReaderConfig_clear(UA_DataSetReaderConfig *cfg) { UA_ExtensionObject_clear(&cfg->messageSettings); UA_ExtensionObject_clear(&cfg->transportSettings); if(cfg->subscribedDataSetType == UA_PUBSUB_SDS_TARGET) { - UA_TargetVariables_clear(&cfg->subscribedDataSet.subscribedDataSetTarget); + UA_TargetVariablesDataType_clear(&cfg->subscribedDataSet.target); } } @@ -420,46 +407,12 @@ UA_DataSetReader_setPubSubState(UA_PubSubManager *psm, UA_DataSetReader *dsr, } } -UA_StatusCode -UA_FieldTargetVariable_copy(const UA_FieldTargetVariable *src, - UA_FieldTargetVariable *dst) { - memcpy(dst, src, sizeof(UA_FieldTargetVariable)); - return UA_FieldTargetDataType_copy(&src->targetVariable, - &dst->targetVariable); -} - -UA_StatusCode -UA_TargetVariables_copy(const UA_TargetVariables *src, UA_TargetVariables *dst) { - UA_StatusCode retVal = UA_STATUSCODE_GOOD; - memcpy(dst, src, sizeof(UA_TargetVariables)); - if(src->targetVariablesSize > 0) { - dst->targetVariables = (UA_FieldTargetVariable*) - UA_calloc(src->targetVariablesSize, sizeof(UA_FieldTargetVariable)); - if(!dst->targetVariables) - return UA_STATUSCODE_BADOUTOFMEMORY; - for(size_t i = 0; i < src->targetVariablesSize; i++) - retVal |= UA_FieldTargetVariable_copy(&src->targetVariables[i], - &dst->targetVariables[i]); - } - return retVal; -} - -void -UA_TargetVariables_clear(UA_TargetVariables *tvs) { - for(size_t i = 0; i < tvs->targetVariablesSize; i++) { - UA_FieldTargetDataType_clear(&tvs->targetVariables[i].targetVariable); - } - if(tvs->targetVariablesSize > 0) - UA_free(tvs->targetVariables); - memset(tvs, 0, sizeof(UA_TargetVariables)); -} - /* This Method is used to initially set the SubscribedDataSet to * TargetVariablesType and to create the list of target Variables of a * SubscribedDataSetType. */ UA_StatusCode DataSetReader_createTargetVariables(UA_PubSubManager *psm, UA_DataSetReader *dsr, - size_t tvsSize, const UA_FieldTargetVariable *tvs) { + size_t tvsSize, const UA_FieldTargetDataType *tvs) { UA_LOCK_ASSERT(&psm->sc.server->serviceMutex); if(UA_PubSubState_isEnabled(dsr->head.state)) { @@ -469,29 +422,36 @@ DataSetReader_createTargetVariables(UA_PubSubManager *psm, UA_DataSetReader *dsr return UA_STATUSCODE_BADCONFIGURATIONERROR; } - if(dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize > 0) - UA_TargetVariables_clear(&dsr->config.subscribedDataSet.subscribedDataSetTarget); + UA_TargetVariablesDataType newVars; + UA_TargetVariablesDataType tmp = {tvsSize, (UA_FieldTargetDataType*)(uintptr_t)tvs}; + UA_StatusCode res = UA_TargetVariablesDataType_copy(&tmp, &newVars); + if(res != UA_STATUSCODE_GOOD) + return res; - /* Set subscribed dataset to TargetVariableType */ - dsr->config.subscribedDataSetType = UA_PUBSUB_SDS_TARGET; - UA_TargetVariables tmp; - tmp.targetVariablesSize = tvsSize; - tmp.targetVariables = (UA_FieldTargetVariable*)(uintptr_t)tvs; - return UA_TargetVariables_copy(&tmp, &dsr->config.subscribedDataSet.subscribedDataSetTarget); + UA_TargetVariablesDataType_clear(&dsr->config.subscribedDataSet.target); + dsr->config.subscribedDataSet.target = newVars; + return UA_STATUSCODE_GOOD; } static void DataSetReader_processRaw(UA_PubSubManager *psm, UA_DataSetReader *dsr, UA_DataSetMessage* msg) { UA_LOG_TRACE_PUBSUB(psm->logging, dsr, "Received RAW Frame"); + + if(dsr->config.dataSetMetaData.fieldsSize != + dsr->config.subscribedDataSet.target.targetVariablesSize) { + UA_LOG_ERROR_PUBSUB(psm->logging, dsr, "Inconsistent number of fields configured"); + return; + } + msg->data.keyFrameData.fieldCount = (UA_UInt16) dsr->config.dataSetMetaData.fieldsSize; /* Start iteration from beginning of rawFields buffer */ size_t offset = 0; - for(size_t i = 0; i < dsr->config.dataSetMetaData.fieldsSize; i++) { - UA_FieldTargetVariable *tv = - &dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; + UA_TargetVariablesDataType *tvs = &dsr->config.subscribedDataSet.target; + for(size_t i = 0; i < tvs->targetVariablesSize ; i++) { + UA_FieldTargetDataType *tv = &tvs->targetVariables[i]; /* TODO The datatype reference should be part of the internal * pubsub configuration to avoid the time-expensive lookup */ @@ -548,36 +508,22 @@ DataSetReader_processRaw(UA_PubSubManager *psm, UA_DataSetReader *dsr, } /* Write the value */ - if(tv->externalDataValue) { - if(tv->beforeWrite) - tv->beforeWrite(psm->sc.server, &dsr->head.identifier, - &dsr->linkedReaderGroup->head.identifier, - &tv->targetVariable.targetNodeId, - tv->targetVariableContext, tv->externalDataValue); - memcpy((*tv->externalDataValue)->value.data, value, type->memSize); - if(tv->afterWrite) - tv->afterWrite(psm->sc.server, &dsr->head.identifier, - &dsr->linkedReaderGroup->head.identifier, - &tv->targetVariable.targetNodeId, - tv->targetVariableContext, tv->externalDataValue); + UA_WriteValue writeVal; + UA_WriteValue_init(&writeVal); + writeVal.attributeId = tv->attributeId; + writeVal.indexRange = tv->receiverIndexRange; + writeVal.nodeId = tv->targetNodeId; + if(dsr->config.dataSetMetaData.fields[i].valueRank > 0) { + UA_Variant_setArray(&writeVal.value.value, value, elementCount, type); } else { - UA_WriteValue writeVal; - UA_WriteValue_init(&writeVal); - writeVal.attributeId = tv->targetVariable.attributeId; - writeVal.indexRange = tv->targetVariable.receiverIndexRange; - writeVal.nodeId = tv->targetVariable.targetNodeId; - if(dsr->config.dataSetMetaData.fields[i].valueRank > 0) { - UA_Variant_setArray(&writeVal.value.value, value, elementCount, type); - } else { - UA_Variant_setScalar(&writeVal.value.value, value, type); - } - writeVal.value.hasValue = true; - Operation_Write(psm->sc.server, &psm->sc.server->adminSession, NULL, &writeVal, &res); - if(res != UA_STATUSCODE_GOOD) { - UA_LOG_WARNING_PUBSUB(psm->logging, dsr, - "Error writing KeyFrame field %u: %s", - (unsigned)i, UA_StatusCode_name(res)); - } + UA_Variant_setScalar(&writeVal.value.value, value, type); + } + writeVal.value.hasValue = true; + Operation_Write(psm->sc.server, &psm->sc.server->adminSession, NULL, &writeVal, &res); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_PUBSUB(psm->logging, dsr, + "Error writing KeyFrame field %u: %s", + (unsigned)i, UA_StatusCode_name(res)); } /* Clean up if string-type (with mallocs) was used */ @@ -688,8 +634,7 @@ UA_DataSetReader_process(UA_PubSubManager *psm, UA_DataSetReader *dsr, return; } - UA_TargetVariables *tvs = - &dsr->config.subscribedDataSet.subscribedDataSetTarget; + UA_TargetVariablesDataType *tvs = &dsr->config.subscribedDataSet.target;; if(tvs->targetVariablesSize != fieldCount) { UA_LOG_WARNING_PUBSUB(psm->logging, dsr, "Number of fields does not match the " @@ -700,39 +645,17 @@ UA_DataSetReader_process(UA_PubSubManager *psm, UA_DataSetReader *dsr, /* Write the message fields. RT has the external data value configured. */ UA_StatusCode res = UA_STATUSCODE_GOOD; for(size_t i = 0; i < fieldCount; i++) { - UA_FieldTargetVariable *tv = &tvs->targetVariables[i]; + UA_FieldTargetDataType *tv = &tvs->targetVariables[i]; UA_DataValue *field = &msg->data.keyFrameData.dataSetFields[i]; if(!field->hasValue) continue; - /* RT-path: write directly into the target memory */ - if(tv->externalDataValue) { - if(field->value.type != (*tv->externalDataValue)->value.type) { - UA_LOG_WARNING_PUBSUB(psm->logging, dsr, "Mismatching type"); - continue; - } - - if(tv->beforeWrite) - tv->beforeWrite(psm->sc.server, &dsr->head.identifier, - &dsr->linkedReaderGroup->head.identifier, - &tv->targetVariable.targetNodeId, - tv->targetVariableContext, tv->externalDataValue); - memcpy((*tv->externalDataValue)->value.data, - field->value.data, field->value.type->memSize); - if(tv->afterWrite) - tv->afterWrite(psm->sc.server, &dsr->head.identifier, - &dsr->linkedReaderGroup->head.identifier, - &tv->targetVariable.targetNodeId, - tv->targetVariableContext, tv->externalDataValue); - continue; - } - /* Write via the Write-Service */ UA_WriteValue writeVal; UA_WriteValue_init(&writeVal); - writeVal.attributeId = tv->targetVariable.attributeId; - writeVal.indexRange = tv->targetVariable.receiverIndexRange; - writeVal.nodeId = tv->targetVariable.targetNodeId; + writeVal.attributeId = tv->attributeId; + writeVal.indexRange = tv->receiverIndexRange; + writeVal.nodeId = tv->targetNodeId; writeVal.value = *field; Operation_Write(psm->sc.server, &psm->sc.server->adminSession, NULL, &writeVal, &res); @@ -840,14 +763,15 @@ UA_Server_disableDataSetReader(UA_Server *server, const UA_NodeId dsrId) { UA_StatusCode UA_Server_setDataSetReaderTargetVariables(UA_Server *server, const UA_NodeId dsrId, - size_t tvsSize, const UA_FieldTargetVariable *tvs) { + size_t targetVariablesSize, const UA_FieldTargetDataType *targetVariables) { if(!server) return UA_STATUSCODE_BADINVALIDARGUMENT; UA_LOCK(&server->serviceMutex); UA_PubSubManager *psm = getPSM(server); UA_DataSetReader *dsr = UA_DataSetReader_find(psm, dsrId); UA_StatusCode res = (dsr) ? - DataSetReader_createTargetVariables(psm, dsr, tvsSize, tvs) : UA_STATUSCODE_BADNOTFOUND; + DataSetReader_createTargetVariables(psm, dsr, targetVariablesSize, + targetVariables) : UA_STATUSCODE_BADNOTFOUND; UA_UNLOCK(&server->serviceMutex); return res; } diff --git a/src/pubsub/ua_pubsub_readergroup.c b/src/pubsub/ua_pubsub_readergroup.c index 9da7eb33d..d476f8531 100644 --- a/src/pubsub/ua_pubsub_readergroup.c +++ b/src/pubsub/ua_pubsub_readergroup.c @@ -990,7 +990,7 @@ UA_PubSubDataSetReader_generateKeyFrameMessage(UA_Server *server, UA_DataSetMessage *dsm, UA_DataSetReader *dsr) { /* Prepare DataSetMessageContent */ - UA_TargetVariables *tv = &dsr->config.subscribedDataSet.subscribedDataSetTarget; + UA_TargetVariablesDataType *tv = &dsr->config.subscribedDataSet.target; dsm->header.dataSetMessageValid = true; dsm->header.dataSetMessageType = UA_DATASETMESSAGE_DATAKEYFRAME; dsm->data.keyFrameData.fieldCount = (UA_UInt16) tv->targetVariablesSize; @@ -1003,16 +1003,15 @@ UA_PubSubDataSetReader_generateKeyFrameMessage(UA_Server *server, &dsr->config.dataSetMetaData; for(size_t counter = 0; counter < tv->targetVariablesSize; counter++) { - /* Sample the value and set the source in the reader config */ + /* Read the value and set the source in the reader config */ UA_DataValue *dfv = &dsm->data.keyFrameData.dataSetFields[counter]; - UA_FieldTargetVariable *ftv = &tv->targetVariables[counter]; + UA_FieldTargetDataType *ftv = &tv->targetVariables[counter]; UA_ReadValueId rvi; UA_ReadValueId_init(&rvi); - rvi.nodeId = ftv->targetVariable.targetNodeId; - rvi.attributeId = ftv->targetVariable.attributeId; - rvi.indexRange = ftv->targetVariable.writeIndexRange; - + rvi.nodeId = ftv->targetNodeId; + rvi.attributeId = ftv->attributeId; + rvi.indexRange = ftv->writeIndexRange; *dfv = readWithSession(server, &server->adminSession, &rvi, UA_TIMESTAMPSTORETURN_NEITHER); @@ -1278,20 +1277,17 @@ UA_Server_computeReaderGroupOffsetTable(UA_Server *server, UA_NodeId_copy(&dsr->head.identifier, &o->component); break; case UA_PUBSUBOFFSETTYPE_DATASETFIELD_DATAVALUE: - tv = &dsr->config.subscribedDataSet.subscribedDataSetTarget. - targetVariables[fieldindex].targetVariable; + tv = &dsr->config.subscribedDataSet.target.targetVariables[fieldindex]; UA_NodeId_copy(&tv->targetNodeId, &o->component); fieldindex++; break; case UA_PUBSUBOFFSETTYPE_DATASETFIELD_VARIANT: - tv = &dsr->config.subscribedDataSet.subscribedDataSetTarget. - targetVariables[fieldindex].targetVariable; + tv = &dsr->config.subscribedDataSet.target.targetVariables[fieldindex]; UA_NodeId_copy(&tv->targetNodeId, &o->component); fieldindex++; break; case UA_PUBSUBOFFSETTYPE_DATASETFIELD_RAW: - tv = &dsr->config.subscribedDataSet.subscribedDataSetTarget. - targetVariables[fieldindex].targetVariable; + tv = &dsr->config.subscribedDataSet.target.targetVariables[fieldindex]; UA_NodeId_copy(&tv->targetNodeId, &o->component); fieldindex++; break; diff --git a/tests/pubsub/check_pubsub_config_freeze.c b/tests/pubsub/check_pubsub_config_freeze.c index a7ab43385..37569d080 100644 --- a/tests/pubsub/check_pubsub_config_freeze.c +++ b/tests/pubsub/check_pubsub_config_freeze.c @@ -349,8 +349,8 @@ START_TEST(CreateConfigWithStaticFieldSource) { memset(&fieldConfig, 0, sizeof(UA_DataSetFieldConfig)); fieldConfig.dataSetFieldType = UA_PUBSUB_DATASETFIELD_VARIABLE; fieldConfig.field.variable.fieldNameAlias = UA_STRING("field 1"); - fieldConfig.field.variable.rtValueSource.rtFieldSourceEnabled = UA_TRUE; - fieldConfig.field.variable.rtValueSource.staticValueSource = &dataValue; + fieldConfig.field.variable.publishParameters.publishedVariable = + UA_NS0ID(SERVER_SERVERSTATUS); UA_NodeId localDataSetField; retVal |= UA_Server_addDataSetField(server, publishedDataSet1, &fieldConfig, &localDataSetField).result; diff --git a/tests/pubsub/check_pubsub_custom_state_machine.c b/tests/pubsub/check_pubsub_custom_state_machine.c index 42e1d87ec..62aacc17e 100644 --- a/tests/pubsub/check_pubsub_custom_state_machine.c +++ b/tests/pubsub/check_pubsub_custom_state_machine.c @@ -161,8 +161,6 @@ START_TEST(CustomPublisher) { for(size_t i = 0; i < PUBSUB_CONFIG_FIELD_COUNT; i++) { /* TODO: Point to a variable in the information model */ memset(&dsfConfig, 0, sizeof(UA_DataSetFieldConfig)); - dsfConfig.field.variable.rtValueSource.rtFieldSourceEnabled = true; - dsfConfig.field.variable.rtValueSource.staticValueSource = &dvPointers[i]; UA_Server_addDataSetField(server, publishedDataSetIdent, &dsfConfig, &dataSetFieldIdent); } @@ -387,10 +385,6 @@ connectionStateMachine(UA_Server *server, const UA_NodeId componentId, return UA_STATUSCODE_GOOD; } -/* Simulate a custom data sink (e.g. shared memory) */ -UA_UInt32 repeatedFieldValues[PUBSUB_CONFIG_FIELD_COUNT]; -UA_DataValue *repeatedDataValueRT[PUBSUB_CONFIG_FIELD_COUNT]; - /* If the external data source is written over the information model, the * externalDataWriteCallback will be triggered. The user has to take care and assure * that the write leads not to synchronization issues and race conditions. */ @@ -521,12 +515,9 @@ addSubscribedVariables (UA_Server *server) { /* Set the subscribed data to TargetVariable type */ readerConfig.subscribedDataSetType = UA_PUBSUB_SDS_TARGET; /* Create the TargetVariables with respect to DataSetMetaData fields */ - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize = - readerConfig.dataSetMetaData.fieldsSize; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables = - (UA_FieldTargetVariable *)UA_calloc( - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize, - sizeof(UA_FieldTargetVariable)); + readerConfig.subscribedDataSet.target.targetVariablesSize = readerConfig.dataSetMetaData.fieldsSize; + readerConfig.subscribedDataSet.target.targetVariables = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.subscribedDataSet.target.targetVariablesSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -545,33 +536,10 @@ addSubscribedVariables (UA_Server *server) { UA_QUALIFIEDNAME(1, "Subscribed UInt32"), UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); - repeatedFieldValues[i] = 0; - repeatedDataValueRT[i] = UA_DataValue_new(); - UA_Variant_setScalar(&repeatedDataValueRT[i]->value, &repeatedFieldValues[i], - &UA_TYPES[UA_TYPES_UINT32]); - repeatedDataValueRT[i]->value.storageType = UA_VARIANT_DATA_NODELETE; - repeatedDataValueRT[i]->hasValue = true; - /* Set the value backend of the above create node to 'external value source' */ - UA_ValueBackend valueBackend; - valueBackend.backendType = UA_VALUEBACKENDTYPE_EXTERNAL; - valueBackend.backend.external.value = &repeatedDataValueRT[i]; - valueBackend.backend.external.callback.userWrite = externalDataWriteCallback; - valueBackend.backend.external.callback.notificationRead = externalDataReadNotificationCallback; - UA_Server_setVariableNode_valueBackend(server, newnodeId, valueBackend); - - UA_FieldTargetVariable *tv = - &readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; - UA_FieldTargetDataType *ftdt = &tv->targetVariable; - - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(ftdt); - ftdt->attributeId = UA_ATTRIBUTEID_VALUE; - ftdt->targetNodeId = newnodeId; - /* set both before and after write callback to show the usage */ - tv->beforeWrite = subscribeBeforeWriteCallback; - tv->externalDataValue = &repeatedDataValueRT[i]; - tv->afterWrite = subscribeAfterWriteCallback; + UA_FieldTargetDataType *tv = &readerConfig.subscribedDataSet.target.targetVariables[i]; + tv->attributeId = UA_ATTRIBUTEID_VALUE; + tv->targetNodeId = newnodeId; } } @@ -610,14 +578,7 @@ addDataSetReader(UA_Server *server) { addSubscribedVariables(server); UA_Server_addDataSetReader(server, readerGroupIdentifier, &readerConfig, &readerIdentifier); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { - UA_FieldTargetVariable *tv = - &readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; - UA_FieldTargetDataType *ftdt = &tv->targetVariable; - UA_FieldTargetDataType_clear(ftdt); - } - - UA_free(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables); + UA_free(readerConfig.subscribedDataSet.target.targetVariables); UA_free(readerConfig.dataSetMetaData.fields); UA_UadpDataSetReaderMessageDataType_delete(dataSetReaderMessage); } @@ -637,11 +598,7 @@ START_TEST(CustomSubscriber) { pthread_join(listenThread, NULL); - UA_StatusCode rv = UA_Server_delete(server); - ck_assert_int_eq(rv, UA_STATUSCODE_GOOD); - for(UA_Int32 i = 0; i < PUBSUB_CONFIG_FIELD_COUNT; i++) { - UA_DataValue_delete(repeatedDataValueRT[i]); - } + UA_Server_delete(server); } END_TEST int main(void) { diff --git a/tests/pubsub/check_pubsub_get_state.c b/tests/pubsub/check_pubsub_get_state.c index 141cdab7b..840ee0b26 100644 --- a/tests/pubsub/check_pubsub_get_state.c +++ b/tests/pubsub/check_pubsub_get_state.c @@ -219,27 +219,21 @@ static void AddDataSetReader( UA_Variant_setScalar(&attr.value, &SubscriberData, &UA_TYPES[UA_TYPES_INT32]); ck_assert(UA_Server_addVariableNode(server, UA_NODEID_NULL, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER), - UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), UA_QUALIFIEDNAME(1, "Subscribed Int32"), - UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), attr, NULL, opSubscriberVarId) == UA_STATUSCODE_GOOD); + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_QUALIFIEDNAME(1, "Subscribed Int32"), + UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), + attr, NULL, opSubscriberVarId) == UA_STATUSCODE_GOOD); - UA_FieldTargetVariable *pTargetVariables = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); - assert(pTargetVariables != 0); - - UA_FieldTargetDataType_init(&pTargetVariables[0].targetVariable); - - pTargetVariables[0].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - pTargetVariables[0].targetVariable.targetNodeId = *opSubscriberVarId; + UA_FieldTargetDataType targetVariable; + UA_FieldTargetDataType_init(&targetVariable); + targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; + targetVariable.targetNodeId = *opSubscriberVarId; ck_assert(UA_Server_DataSetReader_createTargetVariables(server, *opDataSetReaderId, - readerConfig.dataSetMetaData.fieldsSize, pTargetVariables) == UA_STATUSCODE_GOOD); - - UA_FieldTargetDataType_clear(&pTargetVariables[0].targetVariable); - UA_free(pTargetVariables); - pTargetVariables = 0; + 1, &targetVariable) == UA_STATUSCODE_GOOD); UA_free(pDataSetMetaData->fields); - pDataSetMetaData->fields = 0; + pDataSetMetaData->fields = NULL; } /***************************************************************************************************/ diff --git a/tests/pubsub/check_pubsub_mqtt.c b/tests/pubsub/check_pubsub_mqtt.c index e159e91ef..8acb7d25e 100644 --- a/tests/pubsub/check_pubsub_mqtt.c +++ b/tests/pubsub/check_pubsub_mqtt.c @@ -282,8 +282,8 @@ START_TEST(SinglePublishSubscribeDateTime){ ck_assert_int_eq(retval, UA_STATUSCODE_GOOD); /* Create the TargetVariables with respect to DataSetMetaData fields */ - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -301,20 +301,14 @@ START_TEST(SinglePublishSubscribeDateTime){ UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newNode); ck_assert_int_eq(retval, UA_STATUSCODE_GOOD); - - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(&targetVars[i].targetVariable); - targetVars[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars[i].targetVariable.targetNodeId = newNode; + targetVars[i].attributeId = UA_ATTRIBUTEID_VALUE; + targetVars[i].targetNodeId = newNode; } retval = UA_Server_DataSetReader_createTargetVariables(server, subscribedDataSetIdent, readerConfig.dataSetMetaData.fieldsSize, targetVars); ck_assert_int_eq(retval, UA_STATUSCODE_GOOD); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); - UA_free(targetVars); UA_free(readerConfig.dataSetMetaData.fields); diff --git a/tests/pubsub/check_pubsub_offset.c b/tests/pubsub/check_pubsub_offset.c index f2cbc465b..67a3f799a 100644 --- a/tests/pubsub/check_pubsub_offset.c +++ b/tests/pubsub/check_pubsub_offset.c @@ -18,21 +18,10 @@ #define PUBSUB_CONFIG_FIELD_COUNT 10 UA_Server *server; - +UA_DataSetReaderConfig readerConfig; static UA_NodeId publishedDataSetIdent, dataSetFieldIdent, writerGroupIdent, connectionIdentifier; static UA_NodeId readerGroupIdentifier, readerIdentifier; -/* Values in static locations. We cycle the dvPointers double-pointer to the - * next with atomic operations. */ -UA_UInt32 valueStore[PUBSUB_CONFIG_FIELD_COUNT]; -UA_DataValue dvStore[PUBSUB_CONFIG_FIELD_COUNT]; -UA_DataValue *dvPointers[PUBSUB_CONFIG_FIELD_COUNT]; - -UA_UInt32 repeatedFieldValues[PUBSUB_CONFIG_FIELD_COUNT]; -UA_DataValue *repeatedDataValueRT[PUBSUB_CONFIG_FIELD_COUNT]; - -UA_DataSetReaderConfig readerConfig; - static UA_NetworkAddressUrlDataType networkAddressUrl = {{0, NULL}, UA_STRING_STATIC("opc.udp://224.0.0.22:4840/")}; static UA_String transportProfile = @@ -50,14 +39,6 @@ static void teardown(void) { } START_TEST(PublisherOffsets) { - /* Prepare the values */ - for(size_t i = 0; i < PUBSUB_CONFIG_FIELD_COUNT; i++) { - valueStore[i] = (UA_UInt32) i + 1; - UA_Variant_setScalar(&dvStore[i].value, &valueStore[i], &UA_TYPES[UA_TYPES_UINT32]); - dvStore[i].hasValue = true; - dvPointers[i] = &dvStore[i]; - } - /* Add a PubSubConnection */ UA_PubSubConnectionConfig connectionConfig; memset(&connectionConfig, 0, sizeof(connectionConfig)); @@ -84,8 +65,6 @@ START_TEST(PublisherOffsets) { for(size_t i = 0; i < PUBSUB_CONFIG_FIELD_COUNT; i++) { /* TODO: Point to a variable in the information model */ memset(&dsfConfig, 0, sizeof(UA_DataSetFieldConfig)); - dsfConfig.field.variable.rtValueSource.rtFieldSourceEnabled = true; - dsfConfig.field.variable.rtValueSource.staticValueSource = &dvPointers[i]; UA_Server_addDataSetField(server, publishedDataSetIdent, &dsfConfig, &dataSetFieldIdent); } @@ -230,12 +209,10 @@ addSubscribedVariables (UA_Server *server) { /* Set the subscribed data to TargetVariable type */ readerConfig.subscribedDataSetType = UA_PUBSUB_SDS_TARGET; /* Create the TargetVariables with respect to DataSetMetaData fields */ - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize = - readerConfig.dataSetMetaData.fieldsSize; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables = - (UA_FieldTargetVariable *)UA_calloc( - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize, - sizeof(UA_FieldTargetVariable)); + readerConfig.subscribedDataSet.target.targetVariablesSize = readerConfig.dataSetMetaData.fieldsSize; + readerConfig.subscribedDataSet.target.targetVariables = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.subscribedDataSet.target.targetVariablesSize, sizeof(UA_FieldTargetDataType)); + for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -254,28 +231,10 @@ addSubscribedVariables (UA_Server *server) { UA_QUALIFIEDNAME(1, "Subscribed UInt32"), UA_NS0ID(BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); - repeatedFieldValues[i] = 0; - repeatedDataValueRT[i] = UA_DataValue_new(); - UA_Variant_setScalar(&repeatedDataValueRT[i]->value, &repeatedFieldValues[i], - &UA_TYPES[UA_TYPES_UINT32]); - repeatedDataValueRT[i]->value.storageType = UA_VARIANT_DATA_NODELETE; - repeatedDataValueRT[i]->hasValue = true; - /* Set the value backend of the above create node to 'external value source' */ - UA_ValueBackend valueBackend; - memset(&valueBackend, 0, sizeof(UA_ValueBackend)); - valueBackend.backendType = UA_VALUEBACKENDTYPE_EXTERNAL; - valueBackend.backend.external.value = &repeatedDataValueRT[i]; - UA_Server_setVariableNode_valueBackend(server, newnodeId, valueBackend); - - UA_FieldTargetVariable *tv = - &readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; - UA_FieldTargetDataType *ftdt = &tv->targetVariable; - - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(ftdt); - ftdt->attributeId = UA_ATTRIBUTEID_VALUE; - ftdt->targetNodeId = newnodeId; + UA_FieldTargetDataType *tv = &readerConfig.subscribedDataSet.target.targetVariables[i]; + tv->attributeId = UA_ATTRIBUTEID_VALUE; + tv->targetNodeId = newnodeId; } } @@ -313,14 +272,7 @@ addDataSetReader(UA_Server *server) { addSubscribedVariables(server); UA_Server_addDataSetReader(server, readerGroupIdentifier, &readerConfig, &readerIdentifier); - for(size_t i = 0; i < readerConfig.dataSetMetaData.fieldsSize; i++) { - UA_FieldTargetVariable *tv = - &readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; - UA_FieldTargetDataType *ftdt = &tv->targetVariable; - UA_FieldTargetDataType_clear(ftdt); - } - - UA_free(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables); + UA_free(readerConfig.subscribedDataSet.target.targetVariables); UA_free(readerConfig.dataSetMetaData.fields); UA_UadpDataSetReaderMessageDataType_delete(dataSetReaderMessage); } @@ -344,9 +296,6 @@ START_TEST(SubscriberOffsets) { } UA_PubSubOffsetTable_clear(&ot); - for(UA_Int32 i = 0; i < PUBSUB_CONFIG_FIELD_COUNT; i++) { - UA_DataValue_delete(repeatedDataValueRT[i]); - } } END_TEST int main(void) { diff --git a/tests/pubsub/check_pubsub_publisherid.c b/tests/pubsub/check_pubsub_publisherid.c index 4d91a53d2..2fe2c6a04 100644 --- a/tests/pubsub/check_pubsub_publisherid.c +++ b/tests/pubsub/check_pubsub_publisherid.c @@ -117,7 +117,6 @@ AddPublishedDataSet(UA_NodeId *pWriterGroupId, char *pPublishedDataSetName, dataSetFieldConfig.field.variable.publishParameters.publishedVariable = *opPublishedVarId; dataSetFieldConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE; if (UseFastPath) { - dataSetFieldConfig.field.variable.rtValueSource.rtInformationModelNode = UA_TRUE; *oppFastPathPublisherDataValue = UA_DataValue_new(); ck_assert(*oppFastPathPublisherDataValue != 0); UA_Int32 *pPublisherData = UA_Int32_new(); @@ -237,25 +236,17 @@ AddDataSetReader(UA_NodeId *pReaderGroupId, char *pName, ck_assert_int_eq(UA_STATUSCODE_GOOD, UA_Server_setVariableNode_valueBackend(server, *opSubscriberVarId, valueBackend)); } - UA_FieldTargetVariable *pTargetVariables = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); - ck_assert(pTargetVariables != 0); - - UA_FieldTargetDataType_init(&pTargetVariables[0].targetVariable); - - pTargetVariables[0].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - pTargetVariables[0].targetVariable.targetNodeId = *opSubscriberVarId; + UA_FieldTargetDataType targetVariable; + UA_FieldTargetDataType_init(&targetVariable); + targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; + targetVariable.targetNodeId = *opSubscriberVarId; ck_assert_int_eq(UA_STATUSCODE_GOOD, UA_Server_DataSetReader_createTargetVariables(server, *opDataSetReaderId, - readerConfig.dataSetMetaData.fieldsSize, pTargetVariables)); - - UA_FieldTargetDataType_clear(&pTargetVariables[0].targetVariable); - UA_free(pTargetVariables); - pTargetVariables = 0; + 1, &targetVariable)); UA_free(pDataSetMetaData->fields); - pDataSetMetaData->fields = 0; + pDataSetMetaData->fields = NULL; } static void diff --git a/tests/pubsub/check_pubsub_sks_client.c b/tests/pubsub/check_pubsub_sks_client.c index 54b0a923e..bd4cfbbfd 100644 --- a/tests/pubsub/check_pubsub_sks_client.c +++ b/tests/pubsub/check_pubsub_sks_client.c @@ -430,8 +430,8 @@ addSubscriber(UA_Server *server) { UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE), oAttr, NULL, &folderId); ck_assert_int_eq(retval, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *)UA_calloc( - readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType*) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; UA_LocalizedText_copy(&readerConfig.dataSetMetaData.fields->description, @@ -447,14 +447,12 @@ addSubscriber(UA_Server *server) { UA_QUALIFIEDNAME(1, (char *)readerConfig.dataSetMetaData.fields->name.data), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newNode); - /* For creating Targetvariables */ - UA_FieldTargetDataType_init(&targetVars->targetVariable); - targetVars->targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars->targetVariable.targetNodeId = newNode; + targetVars->attributeId = UA_ATTRIBUTEID_VALUE; + targetVars->targetNodeId = newNode; - retval = UA_Server_DataSetReader_createTargetVariables( - server, readerIdentifier, readerConfig.dataSetMetaData.fieldsSize, targetVars); - UA_FieldTargetDataType_clear(&targetVars->targetVariable); + retval = UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, + readerConfig.dataSetMetaData.fieldsSize, + targetVars); UA_free(targetVars); UA_free(readerConfig.dataSetMetaData.fields); diff --git a/tests/pubsub/check_pubsub_subscribe.c b/tests/pubsub/check_pubsub_subscribe.c index af5578263..30d8e81e2 100644 --- a/tests/pubsub/check_pubsub_subscribe.c +++ b/tests/pubsub/check_pubsub_subscribe.c @@ -606,17 +606,16 @@ START_TEST(SinglePublishSubscribeDateTime) { pMetaData->fields[0].builtInType = UA_NS0ID_DATETIME; pMetaData->fields[0].valueRank = -1; /* scalar */ - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize = 1; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize, sizeof(UA_FieldTargetVariable)); + readerConfig.subscribedDataSet.target.targetVariablesSize = 1; + readerConfig.subscribedDataSet.target.targetVariables = (UA_FieldTargetDataType *) + UA_calloc(1, sizeof(UA_FieldTargetDataType)); /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[0].targetVariable); - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[0].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[0].targetVariable.targetNodeId = nodeIdDateTime; + readerConfig.subscribedDataSet.target.targetVariables->attributeId = UA_ATTRIBUTEID_VALUE; + readerConfig.subscribedDataSet.target.targetVariables->targetNodeId = nodeIdDateTime; retVal |= UA_Server_addDataSetReader(server, readerGroupId, &readerConfig, &readerIdentifier); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_free(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables); + UA_free(readerConfig.subscribedDataSet.target.targetVariables); /* run server - publisher and subscriber */ ck_assert_int_eq(UA_STATUSCODE_GOOD, UA_Server_enableAllPubSubComponents(server)); @@ -692,19 +691,18 @@ START_TEST(SinglePublishSubscribeDateTimeRaw) { pMetaData->fields[0].builtInType = UA_NS0ID_DATETIME; pMetaData->fields[0].valueRank = -1; /* scalar */ - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize = 1; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize, sizeof(UA_FieldTargetVariable)); + readerConfig.subscribedDataSet.target.targetVariablesSize = 1; + readerConfig.subscribedDataSet.target.targetVariables = (UA_FieldTargetDataType*) + UA_calloc(1, sizeof(UA_FieldTargetDataType)); /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[0].targetVariable); - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[0].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[0].targetVariable.targetNodeId = nodeIdDateTime; + readerConfig.subscribedDataSet.target.targetVariables->attributeId = UA_ATTRIBUTEID_VALUE; + readerConfig.subscribedDataSet.target.targetVariables->targetNodeId = nodeIdDateTime; retVal |= UA_Server_addDataSetReader(server, readerGroupId, &readerConfig, &readerIdentifier); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_free(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables); /* run server - publisher and subscriber */ + UA_free(readerConfig.subscribedDataSet.target.targetVariables); ck_assert_int_eq(UA_STATUSCODE_GOOD, UA_Server_enableAllPubSubComponents(server)); UA_free(pMetaData->fields); }END_TEST @@ -831,19 +829,16 @@ START_TEST(SinglePublishSubscribeInt32) { UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); - /* run server - publisher and subscriber */ ck_assert_int_eq(UA_STATUSCODE_GOOD, UA_Server_enableAllPubSubComponents(server)); @@ -979,16 +974,14 @@ START_TEST(SinglePublishSubscribeInt32StatusCode) { UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), UA_QUALIFIEDNAME(1, "Subscribed Int32"), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); /* Write the value back - but with a status code */ @@ -1149,16 +1142,14 @@ START_TEST(SinglePublishSubscribeInt64) { UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); /* run server - publisher and subscriber */ @@ -1297,16 +1288,14 @@ START_TEST(SinglePublishSubscribeBool) { UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); /* run server - publisher and subscriber */ @@ -1448,16 +1437,14 @@ START_TEST(SinglePublishSubscribewithValidIdentifiers) { UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); /* run server - publisher and subscriber */ @@ -1533,12 +1520,6 @@ START_TEST(SinglePublishSubscribeHeartbeat) { retVal |= UA_Server_addDataSetReader(server, readerGroupId, &readerConfig, &readerIdentifier); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - - ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - //UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); ck_assert_int_eq(UA_STATUSCODE_GOOD, UA_Server_enableAllPubSubComponents(server)); @@ -1676,16 +1657,14 @@ START_TEST(SinglePublishSubscribeWithoutPayloadHeader) { UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), UA_QUALIFIEDNAME(1, "Subscribed Int32"), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); /* run server - publisher and subscriber */ @@ -1826,10 +1805,10 @@ START_TEST(MultiPublishSubscribeInt32) { ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); /* For creating Targetvariable */ - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); @@ -1849,11 +1828,11 @@ START_TEST(MultiPublishSubscribeInt32) { ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); /* Create Targetvariable */ - targetVar.targetVariable.targetNodeId = newnodeId2; + targetVar.targetNodeId = newnodeId2; retVal |= UA_Server_DataSetReader_createTargetVariables(server, reader2Id, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); + UA_FieldTargetDataType_clear(&targetVar); UA_free(pMetaData->fields); /* run server - publisher and subscriber */ @@ -2150,16 +2129,15 @@ START_TEST(SinglePublishOnDemand) { UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); + UA_FieldTargetDataType_clear(&targetVar); UA_free(pMetaData->fields); /* run server - publisher and subscriber */ @@ -2307,16 +2285,14 @@ START_TEST(ValidConfiguredSizPublishSubscribe) { UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), UA_QUALIFIEDNAME(1, "Subscribed Int32"), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); /* run server - publisher and subscriber */ @@ -2453,16 +2429,14 @@ START_TEST(InvalidConfiguredSizPublishSubscribe) { UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), UA_QUALIFIEDNAME(1, "Subscribed Int32"), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; + + UA_FieldTargetDataType targetVar; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); /* run server - publisher and subscriber */ diff --git a/tests/pubsub/check_pubsub_subscribe_config_freeze.c b/tests/pubsub/check_pubsub_subscribe_config_freeze.c index 96a8e8e30..a37a56634 100644 --- a/tests/pubsub/check_pubsub_subscribe_config_freeze.c +++ b/tests/pubsub/check_pubsub_subscribe_config_freeze.c @@ -201,8 +201,8 @@ START_TEST(CreateLockAndEditConfiguration) { folderBrowseName, UA_NODEID_NUMERIC (0, UA_NS0ID_BASEOBJECTTYPE), oAttr, NULL, &folderId); - UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) - UA_calloc(dataSetReaderConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *targetVars = (UA_FieldTargetDataType *) + UA_calloc(dataSetReaderConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); for(size_t i = 0; i < dataSetReaderConfig.dataSetMetaData.fieldsSize; i++) { /* Variable to subscribe data */ UA_VariableAttributes vAttr = UA_VariableAttributes_default; @@ -219,9 +219,8 @@ START_TEST(CreateLockAndEditConfiguration) { UA_QUALIFIEDNAME(1, (char *)dataSetReaderConfig.dataSetMetaData.fields[i].name.data), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newNode); - UA_FieldTargetDataType_init(&targetVars[i].targetVariable); - targetVars[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVars[i].targetVariable.targetNodeId = newNode; + targetVars[i].attributeId = UA_ATTRIBUTEID_VALUE; + targetVars[i].targetNodeId = newNode; } retVal = UA_Server_enableDataSetReader(server, dataSetReader1); @@ -251,9 +250,6 @@ START_TEST(CreateLockAndEditConfiguration) { targetVars); ck_assert(retVal == UA_STATUSCODE_GOOD); retVal = UA_Server_addDataSetReader(server, readerGroup1, &dataSetReaderConfig, &dataSetReader2); - for(size_t i = 0; i < dataSetReaderConfig.dataSetMetaData.fieldsSize; i++) - UA_FieldTargetDataType_clear(&targetVars[i].targetVariable); - UA_free(targetVars); UA_free(dataSetReaderConfig.dataSetMetaData.fields); ck_assert(retVal == UA_STATUSCODE_GOOD); diff --git a/tests/pubsub/check_pubsub_subscribe_encrypted.c b/tests/pubsub/check_pubsub_subscribe_encrypted.c index ef6d972ee..e23cc6864 100644 --- a/tests/pubsub/check_pubsub_subscribe_encrypted.c +++ b/tests/pubsub/check_pubsub_subscribe_encrypted.c @@ -185,18 +185,16 @@ START_TEST(SinglePublishSubscribeDateTime) { UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize = 1; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize, sizeof(UA_FieldTargetVariable)); + readerConfig.subscribedDataSet.target.targetVariablesSize = 1; + readerConfig.subscribedDataSet.target.targetVariables = (UA_FieldTargetDataType *) + UA_calloc(readerConfig.subscribedDataSet.target.targetVariablesSize, sizeof(UA_FieldTargetDataType)); /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[0].targetVariable); - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[0].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables[0].targetVariable.targetNodeId = newnodeId; - retVal |= UA_Server_addDataSetReader(server, readerGroupTest, &readerConfig, - &readerIdentifier); + readerConfig.subscribedDataSet.target.targetVariables[0].attributeId = UA_ATTRIBUTEID_VALUE; + readerConfig.subscribedDataSet.target.targetVariables[0].targetNodeId = newnodeId; + retVal |= UA_Server_addDataSetReader(server, readerGroupTest, &readerConfig, &readerIdentifier); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_free(readerConfig.subscribedDataSet.subscribedDataSetTarget.targetVariables); + UA_free(readerConfig.subscribedDataSet.target.targetVariables); retVal = UA_Server_enableAllPubSubComponents(server); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); @@ -375,16 +373,13 @@ START_TEST(SinglePublishSubscribeInt32) { UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), UA_QUALIFIEDNAME(1, "Subscribed Int32"), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), vAttr, NULL, &newnodeId); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); - /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = newnodeId; - retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, - 1, &targetVar); + + UA_FieldTargetDataType targetVar; + memset(&targetVar, 0, sizeof(UA_FieldTargetDataType)); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = newnodeId; + retVal |= UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); retVal = UA_Server_enableAllPubSubComponents(server); diff --git a/tests/pubsub/check_pubsub_subscribe_msgrcvtimeout.c b/tests/pubsub/check_pubsub_subscribe_msgrcvtimeout.c index daffcdf7f..fe34a6e33 100644 --- a/tests/pubsub/check_pubsub_subscribe_msgrcvtimeout.c +++ b/tests/pubsub/check_pubsub_subscribe_msgrcvtimeout.c @@ -139,7 +139,6 @@ AddPublishedDataSet(UA_NodeId *pWriterGroupId, char *pPublishedDataSetName, dataSetFieldConfig.field.variable.publishParameters.publishedVariable = *opPublishedVarId; dataSetFieldConfig.field.variable.publishParameters.attributeId = UA_ATTRIBUTEID_VALUE; if (UseFastPath) { - dataSetFieldConfig.field.variable.rtValueSource.rtInformationModelNode = UA_TRUE; pFastPathPublisherValue = UA_DataValue_new(); ck_assert(pFastPathPublisherValue != 0); UA_Int32 *pPublisherData = UA_Int32_new(); @@ -260,19 +259,16 @@ AddDataSetReader(UA_NodeId *pReaderGroupId, char *pName, UA_UInt32 PublisherId, valueBackend)); } - UA_FieldTargetVariable *pTargetVariables = (UA_FieldTargetVariable *) - UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType *pTargetVariables = (UA_FieldTargetDataType *) + UA_calloc(readerConfig.dataSetMetaData.fieldsSize, sizeof(UA_FieldTargetDataType)); ck_assert(pTargetVariables != 0); - UA_FieldTargetDataType_init(&pTargetVariables[0].targetVariable); - - pTargetVariables[0].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - pTargetVariables[0].targetVariable.targetNodeId = *opSubscriberVarId; + pTargetVariables->attributeId = UA_ATTRIBUTEID_VALUE; + pTargetVariables->targetNodeId = *opSubscriberVarId; ck_assert(UA_Server_DataSetReader_createTargetVariables(server, *opDataSetReaderId, readerConfig.dataSetMetaData.fieldsSize, pTargetVariables) == UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&pTargetVariables[0].targetVariable); UA_free(pTargetVariables); pTargetVariables = 0; diff --git a/tests/pubsub/check_pubsub_udp_unicast.c b/tests/pubsub/check_pubsub_udp_unicast.c index e6e4109c1..302abf1a7 100644 --- a/tests/pubsub/check_pubsub_udp_unicast.c +++ b/tests/pubsub/check_pubsub_udp_unicast.c @@ -256,16 +256,14 @@ setupSubscribing(UA_Server *server, UA_NodeId connectionId, &readerIdentifier); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetVariable targetVar; - memset(&targetVar, 0, sizeof(UA_FieldTargetVariable)); + UA_FieldTargetDataType targetVar; /* For creating Targetvariable */ - UA_FieldTargetDataType_init(&targetVar.targetVariable); - targetVar.targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; - targetVar.targetVariable.targetNodeId = targetNodeId; + UA_FieldTargetDataType_init(&targetVar); + targetVar.attributeId = UA_ATTRIBUTEID_VALUE; + targetVar.targetNodeId = targetNodeId; retVal = UA_Server_DataSetReader_createTargetVariables(server, readerIdentifier, - 1, &targetVar); + 1, &targetVar); ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD); - UA_FieldTargetDataType_clear(&targetVar.targetVariable); UA_free(pMetaData->fields); }