github/open62541
7
0
Fork 0
mirror of https://github.com/open62541/open62541.git synced 2025-06-03 04:00:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(pubsub): Remove the old direct-access API

Browse Source 
The public Offset Table API should be used for realtime operations on
the NetworkMessages instead.
This commit is contained in:
Julius Pfrommer 2025-01-15 20:28:44 +01:00 committed by Julius Pfrommer
parent e0ef113a84
commit 5bf6f0c3e7
30 changed files with 299 additions and 842 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
examples/pubsub/pubsub_subscribe_encrypted.c
View File

@ -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);

12
examples/pubsub/pubsub_subscribe_encrypted_tpm.c
View File

@ -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);

12
examples/pubsub/pubsub_subscribe_encrypted_tpm_keystore.c
View File

@ -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);

11
examples/pubsub/server_pubsub_subscribe_custom_monitoring.c
View File

@ -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);

14
examples/pubsub/sks/pubsub_subscribe_encrypted_sks.c
View File

@ -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);

12
examples/pubsub/tutorial_pubsub_mqtt_subscribe.c
View File

@ -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);

25
examples/pubsub/tutorial_pubsub_subscribe.c
View File

@ -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);

2
examples/pubsub_realtime/server_pubsub_publish_rt_offsets.c
View File

@ -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);
}

2
examples/pubsub_realtime/server_pubsub_publish_rt_state_machine.c
View File

@ -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);
}

57
examples/pubsub_realtime/server_pubsub_subscribe_rt_offsets.c
View File

@ -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;
}

133
examples/pubsub_realtime/server_pubsub_subscribe_rt_state_machine.c
View File

@ -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;
}

64
include/open62541/server_pubsub.h
View File

@ -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;

31
src/pubsub/ua_pubsub_config.c
View File

@ -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;
}

68
src/pubsub/ua_pubsub_dataset.c
View File

@ -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, &params->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;

17
src/pubsub/ua_pubsub_internal.h
View File

@ -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 */

42
src/pubsub/ua_pubsub_ns0.c
View File

@ -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);
}
/**

174
src/pubsub/ua_pubsub_reader.c
View File

@ -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;
}

22
src/pubsub/ua_pubsub_readergroup.c
View File

@ -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;

4
tests/pubsub/check_pubsub_config_freeze.c
View File

@ -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;

59
tests/pubsub/check_pubsub_custom_state_machine.c
View File

@ -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) {

26
tests/pubsub/check_pubsub_get_state.c
View File

@ -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;
}
/***************************************************************************************************/

14
tests/pubsub/check_pubsub_mqtt.c
View File

@ -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);

69
tests/pubsub/check_pubsub_offset.c
View File

@ -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) {

21
tests/pubsub/check_pubsub_publisherid.c
View File

@ -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

16
tests/pubsub/check_pubsub_sks_client.c
View File

@ -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);

154
tests/pubsub/check_pubsub_subscribe.c
View File

@ -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 */

12
tests/pubsub/check_pubsub_subscribe_config_freeze.c
View File

@ -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);

31
tests/pubsub/check_pubsub_subscribe_encrypted.c
View File

@ -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);

12
tests/pubsub/check_pubsub_subscribe_msgrcvtimeout.c
View File

@ -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;

12
tests/pubsub/check_pubsub_udp_unicast.c
View File

@ -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);
}