END_TEST
START_TEST(Server_HistorizingUpdateInsert)
{
UA_HistoryDataBackend backend = UA_HistoryDataBackend_Memory(1, 1);
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = backend;
setting.maxHistoryDataResponseSize = 1000;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_USER;
serverMutexLock();
UA_StatusCode ret = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
serverMutexUnlock();
ck_assert_str_eq(UA_StatusCode_name(ret), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// fill backend with insert
ck_assert_str_eq(UA_StatusCode_name(updateHistory(UA_PERFORMUPDATETYPE_INSERT, testData, NULL, NULL))
, UA_StatusCode_name(UA_STATUSCODE_GOOD));
UA_HistoryData data;
UA_HistoryData_init(&data);
testResult(testDataSorted, &data);
for (size_t i = 0; i < data.dataValuesSize; ++i) {
ck_assert_uint_eq(data.dataValues[i].hasValue, true);
ck_assert(data.dataValues[i].value.type == &UA_TYPES[UA_TYPES_INT64]);
ck_assert_uint_eq(*((UA_Int64*)data.dataValues[i].value.data), UA_PERFORMUPDATETYPE_INSERT);
}
UA_HistoryData_deleteMembers(&data);
UA_HistoryDataBackend_Memory_deleteMembers(&setting.historizingBackend);
}
/**
* Triggering an event
* ^^^^^^^^^^^^^^^^^^^
* First a node representing an event is generated using ``setUpEvent``. Once our event is good to go, we specify
* a node which emits the event - in this case the server node. We can use ``UA_Server_triggerEvent`` to trigger our
* event onto said node. Passing ``NULL`` as the second-last argument means we will not receive the `EventId`.
* The last boolean argument states whether the node should be deleted. */
static UA_StatusCode
generateEventMethodCallback(UA_Server *server,
const UA_NodeId *sessionId, void *sessionHandle,
const UA_NodeId *methodId, void *methodContext,
const UA_NodeId *objectId, void *objectContext,
size_t inputSize, const UA_Variant *input,
size_t outputSize, UA_Variant *output) {
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "Creating event");
/* set up event */
UA_NodeId eventNodeId;
UA_StatusCode retval = setUpEvent(server, &eventNodeId);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
"Creating event failed. StatusCode %s", UA_StatusCode_name(retval));
return retval;
}
retval = UA_Server_triggerEvent(server, eventNodeId,
UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER),
NULL, UA_TRUE);
if(retval != UA_STATUSCODE_GOOD)
UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
"Triggering event failed. StatusCode %s", UA_StatusCode_name(retval));
return retval;
}
END_TEST
START_TEST(Server_HistorizingRandomIndexBackend)
{
UA_HistoryDataBackend backend = UA_HistoryDataBackend_randomindextest(testData);
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = backend;
setting.maxHistoryDataResponseSize = 1000;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_USER;
serverMutexLock();
UA_StatusCode ret = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
serverMutexUnlock();
ck_assert_str_eq(UA_StatusCode_name(ret), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// read all in one
UA_UInt32 retval = testHistoricalDataBackend(100);
fprintf(stderr, "%d tests failed.\n", retval);
ck_assert_uint_eq(retval, 0);
// read continuous one at one request
retval = testHistoricalDataBackend(1);
fprintf(stderr, "%d tests failed.\n", retval);
ck_assert_uint_eq(retval, 0);
// read continuous two at one request
retval = testHistoricalDataBackend(2);
fprintf(stderr, "%d tests failed.\n", retval);
ck_assert_uint_eq(retval, 0);
UA_HistoryDataBackend_randomindextest_deleteMembers(&backend);
}
int main(void) {
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
UA_StatusCode retval = UA_Client_connect_username(client, "opc.tcp://localhost:4840", "paula", "paula123");
if(retval != UA_STATUSCODE_GOOD) {
UA_Client_delete(client);
return EXIT_FAILURE;
}
UA_NodeId newVariableIdRequest = UA_NODEID_NUMERIC(1, 1001);
UA_NodeId newVariableId = UA_NODEID_NULL;
UA_VariableAttributes newVariableAttributes = UA_VariableAttributes_default;
newVariableAttributes.accessLevel = UA_ACCESSLEVELMASK_READ;
newVariableAttributes.description = UA_LOCALIZEDTEXT_ALLOC("en-US", "NewVariable desc");
newVariableAttributes.displayName = UA_LOCALIZEDTEXT_ALLOC("en-US", "NewVariable");
newVariableAttributes.dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
UA_UInt32 value = 50;
UA_Variant_setScalarCopy(&newVariableAttributes.value, &value, &UA_TYPES[UA_TYPES_UINT32]);
UA_StatusCode retCode;
retCode = UA_Client_addVariableNode(client, newVariableIdRequest,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, "newVariable"),
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
newVariableAttributes, &newVariableId);
printf("addVariable returned: %s\n", UA_StatusCode_name(retCode));
UA_ExpandedNodeId extNodeId = UA_EXPANDEDNODEID_NUMERIC(0, 0);
extNodeId.nodeId = newVariableId;
retCode = UA_Client_addReference(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), UA_TRUE,
UA_STRING_NULL, extNodeId, UA_NODECLASS_VARIABLE);
printf("addReference returned: %s\n", UA_StatusCode_name(retCode));
retCode = UA_Client_deleteReference(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), UA_TRUE, extNodeId,
UA_TRUE);
printf("deleteReference returned: %s\n", UA_StatusCode_name(retCode));
retCode = UA_Client_deleteNode(client, newVariableId, UA_TRUE);
printf("deleteNode returned: %s\n", UA_StatusCode_name(retCode));
/* Clean up */
UA_VariableAttributes_clear(&newVariableAttributes);
UA_Client_delete(client); /* Disconnects the client internally */
return EXIT_SUCCESS;
}
static void
printResult(UA_DataValue * value)
{
if (value->status != UA_STATUSCODE_GOOD)
fprintf(stderr, "%s:", UA_StatusCode_name(value->status));
printTimestamp(value->sourceTimestamp);
}
static int
run(UA_String *transportProfile, UA_NetworkAddressUrlDataType *networkAddressUrl) {
signal(SIGINT, stopHandler);
signal(SIGTERM, stopHandler);
UA_Server *server = UA_Server_new();
UA_ServerConfig *config = UA_Server_getConfig(server);
UA_ServerConfig_setMinimal(config, 4801, NULL);
/* Details about the PubSubTransportLayer can be found inside the
* tutorial_pubsub_connection */
config->pubsubTransportLayers = (UA_PubSubTransportLayer *)
UA_calloc(2, sizeof(UA_PubSubTransportLayer));
if(!config->pubsubTransportLayers) {
UA_Server_delete(server);
return EXIT_FAILURE;
}
config->pubsubTransportLayers[0] = UA_PubSubTransportLayerUDPMP();
config->pubsubTransportLayersSize++;
#ifdef UA_ENABLE_PUBSUB_ETH_UADP
config->pubsubTransportLayers[1] = UA_PubSubTransportLayerEthernet();
config->pubsubTransportLayersSize++;
#endif
UA_PubSubConnectionConfig connectionConfig;
memset(&connectionConfig, 0, sizeof(connectionConfig));
connectionConfig.name = UA_STRING("UADP Connection 1");
connectionConfig.transportProfileUri = *transportProfile;
connectionConfig.enabled = UA_TRUE;
UA_Variant_setScalar(&connectionConfig.address, networkAddressUrl,
&UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]);
UA_NodeId connectionIdent;
UA_StatusCode retval =
UA_Server_addPubSubConnection(server, &connectionConfig, &connectionIdent);
if(retval == UA_STATUSCODE_GOOD)
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER,
"The PubSub Connection was created successfully!");
/* The following lines register the listening on the configured multicast
* address and configure a repeated job, which is used to handle received
* messages. */
UA_PubSubConnection *connection =
UA_PubSubConnection_findConnectionbyId(server, connectionIdent);
if(connection != NULL) {
UA_StatusCode rv = connection->channel->regist(connection->channel, NULL, NULL);
if (rv == UA_STATUSCODE_GOOD) {
UA_UInt64 subscriptionCallbackId;
UA_Server_addRepeatedCallback(server, (UA_ServerCallback)subscriptionPollingCallback,
connection, 100, &subscriptionCallbackId);
} else {
UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "register channel failed: %s!",
UA_StatusCode_name(rv));
}
}
retval |= UA_Server_run(server, &running);
UA_Server_delete(server);
return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;;
}
/**
* Setting up an event
* ^^^^^^^^^^^^^^^^^^^
* In order to set up the event, we can first use ``UA_Server_createEvent`` to give us a node representation of the event.
* All we need for this is our `EventType`. Once we have our event node, which is saved internally as an `ObjectNode`,
* we can define the attributes the event has the same way we would define the attributes of an object node. It is not
* necessary to define the attributes `EventId`, `ReceiveTime`, `SourceNode` or `EventType` since these are set
* automatically by the server. In this example, we will be setting the fields 'Message' and 'Severity' in addition
* to `Time` which is needed to make the example UaExpert compliant.
*/
static UA_StatusCode
setUpEvent(UA_Server *server, UA_NodeId *outId) {
UA_StatusCode retval = UA_Server_createEvent(server, eventType, outId);
if (retval != UA_STATUSCODE_GOOD) {
UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_SERVER,
"createEvent failed. StatusCode %s", UA_StatusCode_name(retval));
return retval;
}
/* Set the Event Attributes */
/* Setting the Time is required or else the event will not show up in UAExpert! */
UA_DateTime eventTime = UA_DateTime_now();
UA_Server_writeObjectProperty_scalar(server, *outId, UA_QUALIFIEDNAME(0, "Time"),
&eventTime, &UA_TYPES[UA_TYPES_DATETIME]);
UA_UInt16 eventSeverity = 100;
UA_Server_writeObjectProperty_scalar(server, *outId, UA_QUALIFIEDNAME(0, "Severity"),
&eventSeverity, &UA_TYPES[UA_TYPES_UINT16]);
UA_LocalizedText eventMessage = UA_LOCALIZEDTEXT("en-US", "An event has been generated.");
UA_Server_writeObjectProperty_scalar(server, *outId, UA_QUALIFIEDNAME(0, "Message"),
&eventMessage, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
UA_String eventSourceName = UA_STRING("Server");
UA_Server_writeObjectProperty_scalar(server, *outId, UA_QUALIFIEDNAME(0, "SourceName"),
&eventSourceName, &UA_TYPES[UA_TYPES_STRING]);
return UA_STATUSCODE_GOOD;
}
static void
writeVariable(UA_Server *server) {
UA_StatusCode retval = UA_Server_writeValueRank(server, pointVariableId, 0);
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
"Setting the Value Rank failed with Status Code %s",
UA_StatusCode_name(retval));
}
int main(void) {
signal(SIGINT, stopHandler);
signal(SIGTERM, stopHandler);
UA_ServerConfig *config = UA_ServerConfig_new_minimal(4801, NULL);
/* Details about the PubSubTransportLayer can be found inside the
* tutorial_pubsub_connection */
config->pubsubTransportLayers = (UA_PubSubTransportLayer *)
UA_malloc(sizeof(UA_PubSubTransportLayer));
if (!config->pubsubTransportLayers) {
UA_ServerConfig_delete(config);
return -1;
}
config->pubsubTransportLayers[0] = UA_PubSubTransportLayerUDPMP();
config->pubsubTransportLayersSize++;
UA_Server *server = UA_Server_new(config);
UA_PubSubConnectionConfig connectionConfig;
memset(&connectionConfig, 0, sizeof(connectionConfig));
connectionConfig.name = UA_STRING("UDP-UADP Connection 1");
connectionConfig.transportProfileUri =
UA_STRING("http://opcfoundation.org/UA-Profile/Transport/pubsub-udp-uadp");
connectionConfig.enabled = UA_TRUE;
UA_NetworkAddressUrlDataType networkAddressUrl =
{UA_STRING_NULL , UA_STRING("opc.udp://224.0.0.22:4840/")};
UA_Variant_setScalar(&connectionConfig.address, &networkAddressUrl,
&UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]);
UA_NodeId connectionIdent;
UA_StatusCode retval =
UA_Server_addPubSubConnection(server, &connectionConfig, &connectionIdent);
if(retval == UA_STATUSCODE_GOOD)
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER,
"The PubSub Connection was created successfully!");
/* The following lines register the listening on the configured multicast
* address and configure a repeated job, which is used to handle received
* messages. */
UA_PubSubConnection *connection =
UA_PubSubConnection_findConnectionbyId(server, connectionIdent);
if(connection != NULL) {
UA_StatusCode rv = connection->channel->regist(connection->channel, NULL);
if (rv == UA_STATUSCODE_GOOD) {
UA_UInt64 subscriptionCallbackId;
UA_Server_addRepeatedCallback(server, (UA_ServerCallback)subscriptionPollingCallback,
connection, 100, &subscriptionCallbackId);
} else {
UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "register channel failed: %s!",
UA_StatusCode_name(rv));
}
}
retval |= UA_Server_run(server, &running);
UA_Server_delete(server);
UA_ServerConfig_delete(config);
return (int)retval;
}
END_TEST
START_TEST(Server_HistorizingBackendMemory)
{
UA_HistoryDataBackend backend = UA_HistoryDataBackend_Memory(1, 1);
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = backend;
setting.maxHistoryDataResponseSize = 1000;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_USER;
serverMutexLock();
UA_StatusCode ret = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
serverMutexUnlock();
ck_assert_str_eq(UA_StatusCode_name(ret), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// empty backend should not crash
UA_UInt32 retval = testHistoricalDataBackend(100);
fprintf(stderr, "%d tests expected failed.\n", retval);
// fill backend
ck_assert_uint_eq(fillHistoricalDataBackend(backend), true);
// read all in one
retval = testHistoricalDataBackend(100);
fprintf(stderr, "%d tests failed.\n", retval);
ck_assert_uint_eq(retval, 0);
// read continuous one at one request
retval = testHistoricalDataBackend(1);
fprintf(stderr, "%d tests failed.\n", retval);
ck_assert_uint_eq(retval, 0);
// read continuous two at one request
retval = testHistoricalDataBackend(2);
fprintf(stderr, "%d tests failed.\n", retval);
ck_assert_uint_eq(retval, 0);
UA_HistoryDataBackend_Memory_deleteMembers(&setting.historizingBackend);
}
static void
testResult(UA_DateTime *resultData, UA_HistoryData * historyData) {
// request
UA_HistoryReadResponse localResponse;
UA_HistoryReadResponse_init(&localResponse);
requestHistory(TIMESTAMP_FIRST, TIMESTAMP_LAST, &localResponse, 0, false, NULL);
// test the response
ck_assert_str_eq(UA_StatusCode_name(localResponse.responseHeader.serviceResult), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(localResponse.resultsSize, 1);
ck_assert_str_eq(UA_StatusCode_name(localResponse.results[0].statusCode), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(localResponse.results[0].historyData.encoding, UA_EXTENSIONOBJECT_DECODED);
ck_assert(localResponse.results[0].historyData.content.decoded.type == &UA_TYPES[UA_TYPES_HISTORYDATA]);
UA_HistoryData * data = (UA_HistoryData *)localResponse.results[0].historyData.content.decoded.data;
if (historyData)
UA_HistoryData_copy(data, historyData);
for (size_t j = 0; j < data->dataValuesSize; ++j) {
ck_assert(resultData[j] != 0);
ck_assert_uint_eq(data->dataValues[j].hasSourceTimestamp, true);
ck_assert_uint_eq(data->dataValues[j].sourceTimestamp, resultData[j]);
}
UA_HistoryReadResponse_deleteMembers(&localResponse);
}
void
UA_MonitoredItem_sampleCallback(UA_Server *server, UA_MonitoredItem *monitoredItem) {
UA_Subscription *sub = monitoredItem->subscription;
UA_Session *session = &server->adminSession;
if(sub)
session = sub->session;
UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Subscription %u | "
"MonitoredItem %i | Sample callback called",
sub ? sub->subscriptionId : 0, monitoredItem->monitoredItemId);
UA_assert(monitoredItem->attributeId != UA_ATTRIBUTEID_EVENTNOTIFIER);
/* Get the node */
const UA_Node *node = UA_Nodestore_getNode(server->nsCtx, &monitoredItem->monitoredNodeId);
/* Sample the value. The sample can still point into the node. */
UA_DataValue value;
UA_DataValue_init(&value);
if(node) {
UA_ReadValueId rvid;
UA_ReadValueId_init(&rvid);
rvid.nodeId = monitoredItem->monitoredNodeId;
rvid.attributeId = monitoredItem->attributeId;
rvid.indexRange = monitoredItem->indexRange;
ReadWithNode(node, server, session, monitoredItem->timestampsToReturn, &rvid, &value);
} else {
value.hasStatus = true;
value.status = UA_STATUSCODE_BADNODEIDUNKNOWN;
}
/* Operate on the sample */
UA_Boolean movedValue = false;
UA_StatusCode retval = sampleCallbackWithValue(server, session, sub, monitoredItem, &value, &movedValue);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_WARNING_SESSION(&server->config.logger, session, "Subscription %u | "
"MonitoredItem %i | Sampling returned the statuscode %s",
sub ? sub->subscriptionId : 0, monitoredItem->monitoredItemId,
UA_StatusCode_name(retval));
}
/* Delete the sample if it was not moved to the notification. */
if(!movedValue)
UA_DataValue_deleteMembers(&value); /* Does nothing for UA_VARIANT_DATA_NODELETE */
if(node)
UA_Nodestore_releaseNode(server->nsCtx, node);
}
/*
* Get the endpoint from the server, where we can call RegisterServer2 (or RegisterServer).
* This is normally the endpoint with highest supported encryption mode.
*
* @param discoveryServerUrl The discovery url from the remote server
* @return The endpoint description (which needs to be freed) or NULL
*/
static
UA_EndpointDescription *getRegisterEndpointFromServer(const char *discoveryServerUrl) {
UA_Client *client = UA_Client_new(UA_ClientConfig_default);
UA_EndpointDescription *endpointArray = NULL;
size_t endpointArraySize = 0;
UA_StatusCode retval = UA_Client_getEndpoints(client, discoveryServerUrl,
&endpointArraySize, &endpointArray);
if (retval != UA_STATUSCODE_GOOD) {
UA_Array_delete(endpointArray, endpointArraySize,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
UA_LOG_ERROR(logger, UA_LOGCATEGORY_SERVER, "GetEndpoints failed with %s", UA_StatusCode_name(retval));
UA_Client_delete(client);
return NULL;
}
UA_LOG_DEBUG(logger, UA_LOGCATEGORY_SERVER, "Server has %ld endpoints", endpointArraySize);
UA_EndpointDescription *foundEndpoint = NULL;
for (size_t i = 0; i < endpointArraySize; i++) {
UA_LOG_DEBUG(logger, UA_LOGCATEGORY_SERVER, "\tURL = %.*s, SecurityMode = %s",
(int) endpointArray[i].endpointUrl.length,
endpointArray[i].endpointUrl.data,
endpointArray[i].securityMode == UA_MESSAGESECURITYMODE_NONE ? "None" :
endpointArray[i].securityMode == UA_MESSAGESECURITYMODE_SIGN ? "Sign" :
endpointArray[i].securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT ? "SignAndEncrypt" :
"Invalid"
);
// find the endpoint with highest supported security mode
if ((UA_String_equal(&endpointArray[i].securityPolicyUri, &UA_SECURITY_POLICY_NONE_URI) ||
UA_String_equal(&endpointArray[i].securityPolicyUri, &UA_SECURITY_POLICY_BASIC128_URI)) && (
foundEndpoint == NULL || foundEndpoint->securityMode < endpointArray[i].securityMode))
foundEndpoint = &endpointArray[i];
}
UA_EndpointDescription *returnEndpoint = NULL;
if (foundEndpoint != NULL) {
returnEndpoint = UA_EndpointDescription_new();
UA_EndpointDescription_copy(foundEndpoint, returnEndpoint);
}
UA_Array_delete(endpointArray, endpointArraySize,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
return returnEndpoint;
}
static UA_StatusCode
setSubscriptionSettings(UA_Server *server, UA_Subscription *subscription,
UA_Double requestedPublishingInterval,
UA_UInt32 requestedLifetimeCount,
UA_UInt32 requestedMaxKeepAliveCount,
UA_UInt32 maxNotificationsPerPublish, UA_Byte priority) {
/* deregister the callback if required */
Subscription_unregisterPublishCallback(server, subscription);
/* re-parameterize the subscription */
subscription->publishingInterval = requestedPublishingInterval;
UA_BOUNDEDVALUE_SETWBOUNDS(server->config.publishingIntervalLimits,
requestedPublishingInterval, subscription->publishingInterval);
/* check for nan*/
if(requestedPublishingInterval != requestedPublishingInterval)
subscription->publishingInterval = server->config.publishingIntervalLimits.min;
UA_BOUNDEDVALUE_SETWBOUNDS(server->config.keepAliveCountLimits,
requestedMaxKeepAliveCount, subscription->maxKeepAliveCount);
UA_BOUNDEDVALUE_SETWBOUNDS(server->config.lifeTimeCountLimits,
requestedLifetimeCount, subscription->lifeTimeCount);
if(subscription->lifeTimeCount < 3 * subscription->maxKeepAliveCount)
subscription->lifeTimeCount = 3 * subscription->maxKeepAliveCount;
subscription->notificationsPerPublish = maxNotificationsPerPublish;
if(maxNotificationsPerPublish == 0 ||
maxNotificationsPerPublish > server->config.maxNotificationsPerPublish)
subscription->notificationsPerPublish = server->config.maxNotificationsPerPublish;
subscription->priority = priority;
UA_StatusCode retval = Subscription_registerPublishCallback(server, subscription);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG_SESSION(&server->config.logger, subscription->session,
"Subscription %u | Could not register publish callback with error code %s",
subscription->subscriptionId, UA_StatusCode_name(retval));
return retval;
}
return UA_STATUSCODE_GOOD;
}
static void
responseActivateSession(UA_Client *client, void *userdata, UA_UInt32 requestId,
void *response) {
UA_ActivateSessionResponse *activateResponse =
(UA_ActivateSessionResponse *) response;
if(activateResponse->responseHeader.serviceResult) {
UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT,
"ActivateSession failed with error code %s",
UA_StatusCode_name(activateResponse->responseHeader.serviceResult));
}
client->connection.state = UA_CONNECTION_ESTABLISHED;
setClientState(client, UA_CLIENTSTATE_SESSION);
#ifdef UA_ENABLE_SUBSCRIPTIONS
/* A new session has been created. We need to clean up the subscriptions */
UA_Client_Subscriptions_clean(client);
#endif
/* Call onConnect (client_async.c) callback */
if(client->asyncConnectCall.callback)
client->asyncConnectCall.callback(client, client->asyncConnectCall.userdata,
requestId + 1,
&activateResponse->responseHeader.serviceResult);
}
/* Combination of UA_Client_getEndpointsInternal and getEndpoints */
static void
responseGetEndpoints(UA_Client *client, void *userdata, UA_UInt32 requestId,
void *response) {
UA_EndpointDescription* endpointArray = NULL;
size_t endpointArraySize = 0;
UA_GetEndpointsResponse* resp;
resp = (UA_GetEndpointsResponse*)response;
if (resp->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
client->connectStatus = resp->responseHeader.serviceResult;
UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT,
"GetEndpointRequest failed with error code %s",
UA_StatusCode_name (client->connectStatus));
UA_GetEndpointsResponse_deleteMembers(resp);
return;
}
endpointArray = resp->endpoints;
endpointArraySize = resp->endpointsSize;
resp->endpoints = NULL;
resp->endpointsSize = 0;
UA_Boolean endpointFound = false;
UA_Boolean tokenFound = false;
UA_String securityNone = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None");
UA_String binaryTransport = UA_STRING("http://opcfoundation.org/UA-Profile/"
"Transport/uatcp-uasc-uabinary");
// TODO: compare endpoint information with client->endpointUri
for(size_t i = 0; i < endpointArraySize; ++i) {
UA_EndpointDescription* endpoint = &endpointArray[i];
/* look out for binary transport endpoints */
/* Note: Siemens returns empty ProfileUrl, we will accept it as binary */
if(endpoint->transportProfileUri.length != 0
&& !UA_String_equal (&endpoint->transportProfileUri,
&binaryTransport))
continue;
/* Look for an endpoint corresponding to the client security policy */
if(!UA_String_equal(&endpoint->securityPolicyUri, &client->channel.securityPolicy->policyUri))
continue;
endpointFound = true;
/* Look for a user token policy with an anonymous token */
for(size_t j = 0; j < endpoint->userIdentityTokensSize; ++j) {
UA_UserTokenPolicy* userToken = &endpoint->userIdentityTokens[j];
/* Usertokens also have a security policy... */
if(userToken->securityPolicyUri.length > 0 &&
!UA_String_equal(&userToken->securityPolicyUri, &securityNone))
continue;
/* Does the token type match the client configuration? */
if((userToken->tokenType == UA_USERTOKENTYPE_ANONYMOUS &&
client->config.userIdentityToken.content.decoded.type !=
&UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN] &&
client->config.userIdentityToken.content.decoded.type != NULL) ||
(userToken->tokenType == UA_USERTOKENTYPE_USERNAME &&
client->config.userIdentityToken.content.decoded.type !=
&UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]) ||
(userToken->tokenType == UA_USERTOKENTYPE_CERTIFICATE &&
client->config.userIdentityToken.content.decoded.type !=
&UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]) ||
(userToken->tokenType == UA_USERTOKENTYPE_ISSUEDTOKEN &&
client->config.userIdentityToken.content.decoded.type !=
&UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]))
continue;
/* Endpoint with matching usertokenpolicy found */
tokenFound = true;
UA_EndpointDescription_deleteMembers(&client->config.endpoint);
UA_EndpointDescription_copy(endpoint, &client->config.endpoint);
UA_UserTokenPolicy_deleteMembers(&client->config.userTokenPolicy);
UA_UserTokenPolicy_copy(userToken, &client->config.userTokenPolicy);
break;
}
}
UA_Array_delete(endpointArray, endpointArraySize,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
if(!endpointFound) {
UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT,
"No suitable endpoint found");
client->connectStatus = UA_STATUSCODE_BADINTERNALERROR;
} else if(!tokenFound) {
UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT,
"No suitable UserTokenPolicy found for the possible endpoints");
client->connectStatus = UA_STATUSCODE_BADINTERNALERROR;
}
requestSession(client, &requestId);
}
/* OPN messges to renew the channel are sent asynchronous */
static UA_StatusCode
openSecureChannelAsync(UA_Client *client/*, UA_Boolean renew*/) {
/* Check if sc is still valid */
/*if(renew && client->nextChannelRenewal - UA_DateTime_nowMonotonic () > 0)
return UA_STATUSCODE_GOOD;*/
UA_Connection *conn = &client->connection;
if(conn->state != UA_CONNECTION_ESTABLISHED)
return UA_STATUSCODE_BADSERVERNOTCONNECTED;
/* Prepare the OpenSecureChannelRequest */
UA_OpenSecureChannelRequest opnSecRq;
UA_OpenSecureChannelRequest_init(&opnSecRq);
opnSecRq.requestHeader.timestamp = UA_DateTime_now();
opnSecRq.requestHeader.authenticationToken = client->authenticationToken;
/*if(renew) {
opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_RENEW;
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL,
"Requesting to renew the SecureChannel");
} else {*/
opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_ISSUE;
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL,
"Requesting to open a SecureChannel");
//}
opnSecRq.securityMode = client->channel.securityMode;
opnSecRq.clientNonce = client->channel.localNonce;
opnSecRq.requestedLifetime = client->config.secureChannelLifeTime;
/* Prepare the entry for the linked list */
UA_UInt32 requestId = ++client->requestId;
/*AsyncServiceCall *ac = NULL;
if(renew) {
ac = (AsyncServiceCall*)UA_malloc(sizeof(AsyncServiceCall));
if (!ac)
return UA_STATUSCODE_BADOUTOFMEMORY;
ac->callback =
(UA_ClientAsyncServiceCallback) processDecodedOPNResponseAsync;
ac->responseType = &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE];
ac->requestId = requestId;
ac->userdata = NULL;
}*/
/* Send the OPN message */
UA_StatusCode retval = UA_SecureChannel_sendAsymmetricOPNMessage (
&client->channel, requestId, &opnSecRq,
&UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
client->connectStatus = retval;
if(retval != UA_STATUSCODE_GOOD) {
client->connectStatus = retval;
UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL,
"Sending OPN message failed with error %s",
UA_StatusCode_name(retval));
UA_Client_disconnect(client);
//if(renew)
// UA_free(ac);
return retval;
}
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL,
"OPN message sent");
/* Store the entry for async processing and return */
/*if(renew) {
LIST_INSERT_HEAD(&client->asyncServiceCalls, ac, pointers);
return retval;
}*/
return retval;
}
/* movedValue returns whether the sample was moved to the notification. The
* default is false. */
static UA_StatusCode
sampleCallbackWithValue(UA_Server *server, UA_Session *session,
UA_Subscription *sub, UA_MonitoredItem *mon,
UA_DataValue *value, UA_Boolean *movedValue) {
UA_assert(mon->attributeId != UA_ATTRIBUTEID_EVENTNOTIFIER);
/* Contains heap-allocated binary encoding of the value if a change was detected */
UA_ByteString binValueEncoding = UA_BYTESTRING_NULL;
/* Has the value changed? Allocates memory in binValueEncoding if necessary.
* value is edited internally so we make a shallow copy. */
UA_Boolean changed = false;
UA_StatusCode retval = detectValueChange(server, mon, *value, &binValueEncoding, &changed);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_WARNING_SESSION(&server->config.logger, session, "Subscription %u | "
"MonitoredItem %i | Value change detection failed with StatusCode %s",
sub ? sub->subscriptionId : 0, mon->monitoredItemId,
UA_StatusCode_name(retval));
return retval;
}
if(!changed) {
UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Subscription %u | "
"MonitoredItem %i | The value has not changed",
sub ? sub->subscriptionId : 0, mon->monitoredItemId);
return UA_STATUSCODE_GOOD;
}
/* The MonitoredItem is attached to a subscription (not server-local).
* Prepare a notification and enqueue it. */
if(sub) {
/* Allocate a new notification */
UA_Notification *newNotification = (UA_Notification *)UA_malloc(sizeof(UA_Notification));
if(!newNotification) {
UA_ByteString_deleteMembers(&binValueEncoding);
return UA_STATUSCODE_BADOUTOFMEMORY;
}
if(value->value.storageType == UA_VARIANT_DATA) {
newNotification->data.value = *value; /* Move the value to the notification */
*movedValue = true;
} else { /* => (value->value.storageType == UA_VARIANT_DATA_NODELETE) */
retval = UA_DataValue_copy(value, &newNotification->data.value);
if(retval != UA_STATUSCODE_GOOD) {
UA_ByteString_deleteMembers(&binValueEncoding);
UA_free(newNotification);
return retval;
}
}
/* <-- Point of no return --> */
UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Subscription %u | "
"MonitoredItem %i | Enqueue a new notification",
sub ? sub->subscriptionId : 0, mon->monitoredItemId);
newNotification->mon = mon;
UA_Notification_enqueue(server, sub, mon, newNotification);
}
/* Store the encoding for comparison */
UA_ByteString_deleteMembers(&mon->lastSampledValue);
mon->lastSampledValue = binValueEncoding;
/* Store the value for filter comparison (we don't want to decode
* lastSampledValue in every iteration). Don't test the return code here. If
* this fails, lastValue is empty and a notification will be forced for the
* next deadband comparison. */
if((mon->filter.dataChangeFilter.deadbandType == UA_DEADBANDTYPE_NONE ||
mon->filter.dataChangeFilter.deadbandType == UA_DEADBANDTYPE_ABSOLUTE ||
mon->filter.dataChangeFilter.deadbandType == UA_DEADBANDTYPE_PERCENT) &&
(mon->filter.dataChangeFilter.trigger == UA_DATACHANGETRIGGER_STATUS ||
mon->filter.dataChangeFilter.trigger == UA_DATACHANGETRIGGER_STATUSVALUE ||
mon->filter.dataChangeFilter.trigger == UA_DATACHANGETRIGGER_STATUSVALUETIMESTAMP)) {
UA_Variant_deleteMembers(&mon->lastValue);
UA_Variant_copy(&value->value, &mon->lastValue);
#ifdef UA_ENABLE_DA
UA_StatusCode_deleteMembers(&mon->lastStatus);
UA_StatusCode_copy(&value->status, &mon->lastStatus);
#endif
}
/* Call the local callback if the MonitoredItem is not attached to a
* subscription. Do this at the very end. Because the callback might delete
* the subscription. */
if(!sub) {
UA_LocalMonitoredItem *localMon = (UA_LocalMonitoredItem*) mon;
void *nodeContext = NULL;
UA_Server_getNodeContext(server, mon->monitoredNodeId, &nodeContext);
localMon->callback.dataChangeCallback(server, mon->monitoredItemId,
localMon->context,
&mon->monitoredNodeId,
nodeContext, mon->attributeId,
value);
}
return UA_STATUSCODE_GOOD;
}
END_TEST
START_TEST(Server_HistorizingStrategyValueSet)
{
// init to a defined value
UA_StatusCode retval = setUInt32(client, outNodeId, 43);
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// set a data backend
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = UA_HistoryDataBackend_Memory(3, 100);
setting.maxHistoryDataResponseSize = 100;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_VALUESET;
serverMutexLock();
retval = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
serverMutexUnlock();
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// fill the data
UA_fakeSleep(100);
UA_DateTime start = UA_DateTime_now();
UA_fakeSleep(100);
for (UA_UInt32 i = 0; i < 10; ++i) {
retval = setUInt32(client, outNodeId, i);
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
UA_fakeSleep(100);
}
UA_DateTime end = UA_DateTime_now();
// request
UA_HistoryReadResponse response;
UA_HistoryReadResponse_init(&response);
requestHistory(start, end, &response, 0, false, NULL);
// test the response
ck_assert_str_eq(UA_StatusCode_name(response.responseHeader.serviceResult), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(response.resultsSize, 1);
for (size_t i = 0; i < response.resultsSize; ++i) {
ck_assert_str_eq(UA_StatusCode_name(response.results[i].statusCode), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(response.results[i].historyData.encoding, UA_EXTENSIONOBJECT_DECODED);
ck_assert(response.results[i].historyData.content.decoded.type == &UA_TYPES[UA_TYPES_HISTORYDATA]);
UA_HistoryData * data = (UA_HistoryData *)response.results[i].historyData.content.decoded.data;
ck_assert(data->dataValuesSize > 0);
for (size_t j = 0; j < data->dataValuesSize; ++j) {
ck_assert(data->dataValues[j].sourceTimestamp >= start && data->dataValues[j].sourceTimestamp < end);
ck_assert_uint_eq(data->dataValues[j].hasSourceTimestamp, true);
ck_assert_str_eq(UA_StatusCode_name(data->dataValues[j].status), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(data->dataValues[j].hasValue, true);
ck_assert(data->dataValues[j].value.type == &UA_TYPES[UA_TYPES_UINT32]);
UA_UInt32 * value = (UA_UInt32 *)data->dataValues[j].value.data;
ck_assert_uint_eq(*value, j);
}
}
UA_HistoryReadResponse_deleteMembers(&response);
UA_HistoryDataBackend_Memory_deleteMembers(&setting.historizingBackend);
}
static UA_StatusCode
register_server_with_discovery_server(UA_Server *server,
const char* discoveryServerUrl,
const UA_Boolean isUnregister,
const char* semaphoreFilePath) {
if(!discoveryServerUrl) {
UA_LOG_ERROR(server->config.logger, UA_LOGCATEGORY_SERVER,
"No discovery server url provided");
return UA_STATUSCODE_BADINTERNALERROR;
}
/* Create the client */
UA_Client *client = UA_Client_new(UA_ClientConfig_default);
if(!client)
return UA_STATUSCODE_BADOUTOFMEMORY;
/* Connect the client */
UA_StatusCode retval = UA_Client_connect(client, discoveryServerUrl);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(server->config.logger, UA_LOGCATEGORY_CLIENT,
"Connecting to the discovery server failed with statuscode %s",
UA_StatusCode_name(retval));
UA_Client_delete(client);
return retval;
}
/* Prepare the request. Do not cleanup the request after the service call,
* as the members are stack-allocated or point into the server config. */
UA_RegisterServer2Request request;
UA_RegisterServer2Request_init(&request);
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
request.server.isOnline = !isUnregister;
request.server.serverUri = server->config.applicationDescription.applicationUri;
request.server.productUri = server->config.applicationDescription.productUri;
request.server.serverType = server->config.applicationDescription.applicationType;
request.server.gatewayServerUri = server->config.applicationDescription.gatewayServerUri;
if(semaphoreFilePath) {
#ifdef UA_ENABLE_DISCOVERY_SEMAPHORE
request.server.semaphoreFilePath =
UA_STRING((char*)(uintptr_t)semaphoreFilePath); /* dirty cast */
#else
UA_LOG_WARNING(server->config.logger, UA_LOGCATEGORY_CLIENT,
"Ignoring semaphore file path. open62541 not compiled "
"with UA_ENABLE_DISCOVERY_SEMAPHORE=ON");
#endif
}
request.server.serverNames = &server->config.applicationDescription.applicationName;
request.server.serverNamesSize = 1;
/* Copy the discovery urls from the server config and the network layers*/
size_t config_discurls = server->config.applicationDescription.discoveryUrlsSize;
size_t nl_discurls = server->config.networkLayersSize;
size_t total_discurls = config_discurls * nl_discurls;
request.server.discoveryUrls = (UA_String*)UA_alloca(sizeof(UA_String) * total_discurls);
request.server.discoveryUrlsSize = config_discurls + nl_discurls;
for(size_t i = 0; i < config_discurls; ++i)
request.server.discoveryUrls[i] = server->config.applicationDescription.discoveryUrls[i];
/* TODO: Add nl only if discoveryUrl not already present */
for(size_t i = 0; i < nl_discurls; ++i) {
UA_ServerNetworkLayer *nl = &server->config.networkLayers[i];
request.server.discoveryUrls[config_discurls + i] = nl->discoveryUrl;
}
UA_MdnsDiscoveryConfiguration mdnsConfig;
UA_MdnsDiscoveryConfiguration_init(&mdnsConfig);
request.discoveryConfigurationSize = 1;
request.discoveryConfiguration = UA_ExtensionObject_new();
UA_ExtensionObject_init(&request.discoveryConfiguration[0]);
request.discoveryConfiguration[0].encoding = UA_EXTENSIONOBJECT_DECODED_NODELETE;
request.discoveryConfiguration[0].content.decoded.type = &UA_TYPES[UA_TYPES_MDNSDISCOVERYCONFIGURATION];
request.discoveryConfiguration[0].content.decoded.data = &mdnsConfig;
mdnsConfig.mdnsServerName = server->config.mdnsServerName;
mdnsConfig.serverCapabilities = server->config.serverCapabilities;
mdnsConfig.serverCapabilitiesSize = server->config.serverCapabilitiesSize;
// First try with RegisterServer2, if that isn't implemented, use RegisterServer
UA_RegisterServer2Response response;
UA_RegisterServer2Response_init(&response);
__UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_REGISTERSERVER2REQUEST],
&response, &UA_TYPES[UA_TYPES_REGISTERSERVER2RESPONSE]);
UA_StatusCode serviceResult = response.responseHeader.serviceResult;
UA_RegisterServer2Response_deleteMembers(&response);
UA_ExtensionObject_delete(request.discoveryConfiguration);
if(serviceResult == UA_STATUSCODE_BADNOTIMPLEMENTED ||
serviceResult == UA_STATUSCODE_BADSERVICEUNSUPPORTED) {
/* Try RegisterServer */
UA_RegisterServerRequest request_fallback;
UA_RegisterServerRequest_init(&request_fallback);
/* Copy from RegisterServer2 request */
request_fallback.requestHeader = request.requestHeader;
request_fallback.server = request.server;
UA_RegisterServerResponse response_fallback;
UA_RegisterServerResponse_init(&response_fallback);
__UA_Client_Service(client, &request_fallback,
&UA_TYPES[UA_TYPES_REGISTERSERVERREQUEST],
&response_fallback,
&UA_TYPES[UA_TYPES_REGISTERSERVERRESPONSE]);
serviceResult = response_fallback.responseHeader.serviceResult;
UA_RegisterServerResponse_deleteMembers(&response_fallback);
}
if(serviceResult != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(server->config.logger, UA_LOGCATEGORY_CLIENT,
"RegisterServer/RegisterServer2 failed with statuscode %s",
UA_StatusCode_name(serviceResult));
}
UA_Client_disconnect(client);
UA_Client_delete(client);
return serviceResult;
}
static void setup(void) {
if (!(MUTEX_INIT(serverMutex))) {
fprintf(stderr, "Server mutex was not created correctly.\n");
exit(1);
}
running = true;
server = UA_Server_new();
UA_ServerConfig *config = UA_Server_getConfig(server);
UA_ServerConfig_setDefault(config);
#ifdef UA_ENABLE_HISTORIZING
gathering = (UA_HistoryDataGathering*)UA_calloc(1, sizeof(UA_HistoryDataGathering));
*gathering = UA_HistoryDataGathering_Default(1);
config->historyDatabase = UA_HistoryDatabase_default(*gathering);
#endif
UA_StatusCode retval = UA_Server_run_startup(server);
if(retval != UA_STATUSCODE_GOOD) {
fprintf(stderr, "Error while calling Server_run_startup. %s\n", UA_StatusCode_name(retval));
UA_Server_delete(server);
exit(1);
}
THREAD_CREATE(server_thread, serverloop);
/* Define the attribute of the uint32 variable node */
UA_VariableAttributes attr = UA_VariableAttributes_default;
UA_UInt32 myUint32 = 40;
UA_Variant_setScalar(&attr.value, &myUint32, &UA_TYPES[UA_TYPES_UINT32]);
attr.description = UA_LOCALIZEDTEXT("en-US","the answer");
attr.displayName = UA_LOCALIZEDTEXT("en-US","the answer");
attr.dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE | UA_ACCESSLEVELMASK_HISTORYREAD | UA_ACCESSLEVELMASK_HISTORYWRITE;
attr.historizing = true;
/* Add the variable node to the information model */
UA_NodeId uint32NodeId = UA_NODEID_STRING(1, "the.answer");
UA_QualifiedName uint32Name = UA_QUALIFIEDNAME(1, "the answer");
parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
UA_NodeId_init(&outNodeId);
retval = UA_Server_addVariableNode(server, uint32NodeId, parentNodeId,
parentReferenceNodeId, uint32Name,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
attr, NULL, &outNodeId);
if (retval != UA_STATUSCODE_GOOD) {
fprintf(stderr, "Error adding variable node. %s\n", UA_StatusCode_name(retval));
UA_Server_delete(server);
exit(1);
}
client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
retval = UA_Client_connect(client, "opc.tcp://localhost:4840");
if (retval != UA_STATUSCODE_GOOD) {
fprintf(stderr, "Client can not connect to opc.tcp://localhost:4840. %s\n", UA_StatusCode_name(retval));
UA_Client_delete(client);
UA_Server_delete(server);
exit(1);
}
UA_Client_recv = client->connection.recv;
client->connection.recv = UA_Client_recvTesting;
}
int main(int argc, char **argv) {
signal(SIGINT, stopHandler); /* catches ctrl-c */
signal(SIGTERM, stopHandler);
UA_ServerConfig *config = UA_ServerConfig_new_default();
UA_String_deleteMembers(&config->applicationDescription.applicationUri);
config->applicationDescription.applicationUri =
UA_String_fromChars("urn:open62541.example.server_register");
config->mdnsServerName = UA_String_fromChars("Sample Server");
// See http://www.opcfoundation.org/UA/schemas/1.03/ServerCapabilities.csv
//config.serverCapabilitiesSize = 1;
//UA_String caps = UA_String_fromChars("LDS");
//config.serverCapabilities = ∩︀
UA_Server *server = UA_Server_new(config);
/* add a variable node to the address space */
UA_Int32 myInteger = 42;
UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, "the answer");
UA_DataSource dateDataSource;
dateDataSource.read = readInteger;
dateDataSource.write = writeInteger;
UA_VariableAttributes attr = UA_VariableAttributes_default;
attr.description = UA_LOCALIZEDTEXT("en-US", "the answer");
attr.displayName = UA_LOCALIZEDTEXT("en-US", "the answer");
UA_Server_addDataSourceVariableNode(server, myIntegerNodeId,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
myIntegerName, UA_NODEID_NULL, attr, dateDataSource,
&myInteger, NULL);
// periodic server register after 10 Minutes, delay first register for 500ms
UA_StatusCode retval =
UA_Server_addPeriodicServerRegisterCallback(server, DISCOVERY_SERVER_ENDPOINT,
10 * 60 * 1000, 500, NULL);
// UA_StatusCode retval = UA_Server_addPeriodicServerRegisterJob(server,
// "opc.tcp://localhost:4840", 10*60*1000, 500, NULL);
if (retval != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(logger, UA_LOGCATEGORY_SERVER,
"Could not create periodic job for server register. StatusCode %s",
UA_StatusCode_name(retval));
UA_Server_delete(server);
UA_ServerConfig_delete(config);
return (int)retval;
}
retval = UA_Server_run(server, &running);
if (retval != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(logger, UA_LOGCATEGORY_SERVER,
"Could not start the server. StatusCode %s",
UA_StatusCode_name(retval));
UA_Server_delete(server);
UA_ServerConfig_delete(config);
return (int)retval;
}
// UNregister the server from the discovery server.
retval = UA_Server_unregister_discovery(server, DISCOVERY_SERVER_ENDPOINT);
//retval = UA_Server_unregister_discovery(server, "opc.tcp://localhost:4840" );
if(retval != UA_STATUSCODE_GOOD)
UA_LOG_ERROR(logger, UA_LOGCATEGORY_SERVER,
"Could not unregister server from discovery server. StatusCode %s",
UA_StatusCode_name(retval));
UA_Server_delete(server);
UA_ServerConfig_delete(config);
return (int)retval;
}
static UA_UInt32
testHistoricalDataBackend(size_t maxResponseSize)
{
const UA_HistorizingNodeIdSettings* setting = gathering->getHistorizingSetting(server, gathering->context, &outNodeId);
UA_HistorizingNodeIdSettings newSetting = *setting;
newSetting.maxHistoryDataResponseSize = maxResponseSize;
gathering->updateNodeIdSetting(server, gathering->context, &outNodeId, newSetting);
UA_UInt32 retval = 0;
size_t i = 0;
testTuple *current = &testRequests[i];
fprintf(stderr, "Testing with maxResponseSize of %lu\n", maxResponseSize);
fprintf(stderr, "Start | End | numValuesPerNode | returnBounds |ContPoint| {Expected}{Result} Result\n");
fprintf(stderr, "------+------+------------------+--------------+---------+----------------\n");
size_t j;
while (current->start || current->end) {
j = 0;
if (current->start == TIMESTAMP_UNSPECIFIED) {
fprintf(stderr, "UNSPEC|");
} else {
fprintf(stderr, " %3lld |", current->start / UA_DATETIME_SEC);
}
if (current->end == TIMESTAMP_UNSPECIFIED) {
fprintf(stderr, "UNSPEC|");
} else {
fprintf(stderr, " %3lld |", current->end / UA_DATETIME_SEC);
}
fprintf(stderr, " %2u | %s | %s | {", current->numValuesPerNode, (current->returnBounds ? "Yes" : " No"), (current->returnContinuationPoint ? "Yes" : " No"));
while (current->result[j]) {
printTimestamp(current->result[j]);
++j;
}
fprintf(stderr, "}");
UA_DataValue *result = NULL;
size_t resultSize = 0;
UA_ByteString continuous;
UA_ByteString_init(&continuous);
UA_Boolean readOk = true;
size_t reseivedValues = 0;
fprintf(stderr, "{");
size_t counter = 0;
do {
UA_HistoryReadResponse response;
UA_HistoryReadResponse_init(&response);
UA_UInt32 numValuesPerNode = current->numValuesPerNode;
if (numValuesPerNode > 0 && numValuesPerNode + (UA_UInt32)reseivedValues > current->numValuesPerNode)
numValuesPerNode = current->numValuesPerNode - (UA_UInt32)reseivedValues;
requestHistory(current->start,
current->end,
&response,
numValuesPerNode,
current->returnBounds,
&continuous);
++counter;
if(response.resultsSize != 1) {
fprintf(stderr, "ResultError:Size %lu %s", response.resultsSize, UA_StatusCode_name(response.responseHeader.serviceResult));
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
UA_StatusCode stat = response.results[0].statusCode;
if (stat == UA_STATUSCODE_BADBOUNDNOTSUPPORTED && current->returnBounds) {
fprintf(stderr, "%s", UA_StatusCode_name(stat));
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
if(response.results[0].historyData.encoding != UA_EXTENSIONOBJECT_DECODED
|| response.results[0].historyData.content.decoded.type != &UA_TYPES[UA_TYPES_HISTORYDATA]) {
fprintf(stderr, "ResultError:HistoryData");
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
UA_HistoryData * data = (UA_HistoryData *)response.results[0].historyData.content.decoded.data;
resultSize = data->dataValuesSize;
result = data->dataValues;
if (resultSize == 0 && continuous.length > 0) {
fprintf(stderr, "continuousResultEmpty");
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
if (resultSize > maxResponseSize) {
fprintf(stderr, "resultToBig");
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
if (stat != UA_STATUSCODE_GOOD) {
fprintf(stderr, "%s", UA_StatusCode_name(stat));
} else {
for (size_t k = 0; k < resultSize; ++k)
printResult(&result[k]);
}
if (stat == UA_STATUSCODE_GOOD && j >= resultSize + reseivedValues) {
for (size_t l = 0; l < resultSize; ++l) {
/* See OPC UA Part 11, Version 1.03, Page 5-6, Table 1, Mark a for details.*/
if (current->result[l + reseivedValues] == TIMESTAMP_LAST && current->end == TIMESTAMP_UNSPECIFIED) {
// This test will work on not continous read, only
if (reseivedValues == 0 && !(l > 0 && result[l].sourceTimestamp == result[l-1].sourceTimestamp + UA_DATETIME_SEC))
readOk = false;
}
/* See OPC UA Part 11, Version 1.03, Page 5-6, Table 1, Mark b for details.*/
if (current->result[l + reseivedValues] == TIMESTAMP_FIRST && current->start == TIMESTAMP_UNSPECIFIED) {
// This test will work on not continous read, only
if (reseivedValues == 0 && !(l > 0 && result[l].sourceTimestamp == result[l-1].sourceTimestamp - UA_DATETIME_SEC))
readOk = false;
}
if (!resultIsEqual(&result[l], current, l + reseivedValues))
readOk = false;
}
if (response.results[0].continuationPoint.length > 0)
fprintf(stderr, "C,");
reseivedValues += resultSize;
if (reseivedValues == j) {
if (current->returnContinuationPoint && response.results[0].continuationPoint.length == 0) {
readOk = false;
fprintf(stderr, "missingContinuationPoint");
}
if (!current->returnContinuationPoint && response.results[0].continuationPoint.length > 0) {
readOk = false;
fprintf(stderr, "unexpectedContinuationPoint");
}
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
UA_ByteString_deleteMembers(&continuous);
UA_ByteString_copy(&response.results[0].continuationPoint, &continuous);
} else {
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
UA_HistoryReadResponse_deleteMembers(&response);
} while (continuous.length > 0);
if (j != reseivedValues) {
readOk = false;
}
UA_ByteString_deleteMembers(&continuous);
if (!readOk) {
fprintf(stderr, "} Fail (%lu requests)\n", counter);
++retval;
} else {
fprintf(stderr, "} OK (%lu requests)\n", counter);
}
current = &testRequests[++i];
}
return retval;
}
/* This function implements the main part of the write service and operates on a
copy of the node (not in single-threaded mode). */
static UA_StatusCode
copyAttributeIntoNode(UA_Server *server, UA_Session *session,
UA_Node *node, const UA_WriteValue *wvalue) {
const void *value = wvalue->value.value.data;
UA_UInt32 userWriteMask = getUserWriteMask(server, session, node);
UA_StatusCode retval = UA_STATUSCODE_GOOD;
const UA_VariableTypeNode *type;
switch(wvalue->attributeId) {
case UA_ATTRIBUTEID_NODEID:
case UA_ATTRIBUTEID_NODECLASS:
case UA_ATTRIBUTEID_USERWRITEMASK:
case UA_ATTRIBUTEID_USERACCESSLEVEL:
case UA_ATTRIBUTEID_USEREXECUTABLE:
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_BROWSENAME:
CHECK_USERWRITEMASK(UA_WRITEMASK_BROWSENAME);
CHECK_DATATYPE_SCALAR(QUALIFIEDNAME);
UA_QualifiedName_deleteMembers(&node->browseName);
UA_QualifiedName_copy((const UA_QualifiedName *)value, &node->browseName);
break;
case UA_ATTRIBUTEID_DISPLAYNAME:
CHECK_USERWRITEMASK(UA_WRITEMASK_DISPLAYNAME);
CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
UA_LocalizedText_deleteMembers(&node->displayName);
UA_LocalizedText_copy((const UA_LocalizedText *)value, &node->displayName);
break;
case UA_ATTRIBUTEID_DESCRIPTION:
CHECK_USERWRITEMASK(UA_WRITEMASK_DESCRIPTION);
CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
UA_LocalizedText_deleteMembers(&node->description);
UA_LocalizedText_copy((const UA_LocalizedText *)value, &node->description);
break;
case UA_ATTRIBUTEID_WRITEMASK:
CHECK_USERWRITEMASK(UA_WRITEMASK_WRITEMASK);
CHECK_DATATYPE_SCALAR(UINT32);
node->writeMask = *(const UA_UInt32*)value;
break;
case UA_ATTRIBUTEID_ISABSTRACT:
CHECK_USERWRITEMASK(UA_WRITEMASK_ISABSTRACT);
CHECK_DATATYPE_SCALAR(BOOLEAN);
retval = writeIsAbstractAttribute(node, *(const UA_Boolean*)value);
break;
case UA_ATTRIBUTEID_SYMMETRIC:
CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_SYMMETRIC);
CHECK_DATATYPE_SCALAR(BOOLEAN);
((UA_ReferenceTypeNode*)node)->symmetric = *(const UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_INVERSENAME:
CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_INVERSENAME);
CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
UA_LocalizedText_deleteMembers(&((UA_ReferenceTypeNode*)node)->inverseName);
UA_LocalizedText_copy((const UA_LocalizedText *)value,
&((UA_ReferenceTypeNode*)node)->inverseName);
break;
case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW);
CHECK_USERWRITEMASK(UA_WRITEMASK_CONTAINSNOLOOPS);
CHECK_DATATYPE_SCALAR(BOOLEAN);
((UA_ViewNode*)node)->containsNoLoops = *(const UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_EVENTNOTIFIER:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
CHECK_USERWRITEMASK(UA_WRITEMASK_EVENTNOTIFIER);
CHECK_DATATYPE_SCALAR(BYTE);
((UA_ViewNode*)node)->eventNotifier = *(const UA_Byte*)value;
break;
case UA_ATTRIBUTEID_VALUE:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
if(node->nodeClass == UA_NODECLASS_VARIABLE) {
/* The access to a value variable is granted via the AccessLevel
* and UserAccessLevel attributes */
UA_Byte accessLevel = getAccessLevel(server, session, (const UA_VariableNode*)node);
if(!(accessLevel & (UA_ACCESSLEVELMASK_WRITE))) {
retval = UA_STATUSCODE_BADNOTWRITABLE;
break;
}
accessLevel = getUserAccessLevel(server, session,
(const UA_VariableNode*)node);
if(!(accessLevel & (UA_ACCESSLEVELMASK_WRITE))) {
retval = UA_STATUSCODE_BADUSERACCESSDENIED;
break;
}
} else { /* UA_NODECLASS_VARIABLETYPE */
CHECK_USERWRITEMASK(UA_WRITEMASK_VALUEFORVARIABLETYPE);
}
retval = writeValueAttribute(server, session, (UA_VariableNode*)node,
&wvalue->value, &wvalue->indexRange);
break;
case UA_ATTRIBUTEID_DATATYPE:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_DATATYPE);
CHECK_DATATYPE_SCALAR(NODEID);
GET_NODETYPE
retval = writeDataTypeAttribute(server, session, (UA_VariableNode*)node,
type, (const UA_NodeId*)value);
UA_Nodestore_release(server, (const UA_Node*)type);
break;
case UA_ATTRIBUTEID_VALUERANK:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_VALUERANK);
CHECK_DATATYPE_SCALAR(INT32);
GET_NODETYPE
retval = writeValueRankAttribute(server, session, (UA_VariableNode*)node,
type, *(const UA_Int32*)value);
UA_Nodestore_release(server, (const UA_Node*)type);
break;
case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
CHECK_USERWRITEMASK(UA_WRITEMASK_ARRRAYDIMENSIONS);
CHECK_DATATYPE_ARRAY(UINT32);
GET_NODETYPE
retval = writeArrayDimensionsAttribute(server, session, (UA_VariableNode*)node,
type, wvalue->value.value.arrayLength,
(UA_UInt32 *)wvalue->value.value.data);
UA_Nodestore_release(server, (const UA_Node*)type);
break;
case UA_ATTRIBUTEID_ACCESSLEVEL:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_USERWRITEMASK(UA_WRITEMASK_ACCESSLEVEL);
CHECK_DATATYPE_SCALAR(BYTE);
((UA_VariableNode*)node)->accessLevel = *(const UA_Byte*)value;
break;
case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_USERWRITEMASK(UA_WRITEMASK_MINIMUMSAMPLINGINTERVAL);
CHECK_DATATYPE_SCALAR(DOUBLE);
((UA_VariableNode*)node)->minimumSamplingInterval = *(const UA_Double*)value;
break;
case UA_ATTRIBUTEID_HISTORIZING:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_USERWRITEMASK(UA_WRITEMASK_HISTORIZING);
CHECK_DATATYPE_SCALAR(BOOLEAN);
((UA_VariableNode*)node)->historizing = *(const UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_EXECUTABLE:
CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD);
CHECK_USERWRITEMASK(UA_WRITEMASK_EXECUTABLE);
CHECK_DATATYPE_SCALAR(BOOLEAN);
((UA_MethodNode*)node)->executable = *(const UA_Boolean*)value;
break;
default:
retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
break;
}
if(retval != UA_STATUSCODE_GOOD)
UA_LOG_INFO_SESSION(server->config.logger, session,
"WriteRequest returned status code %s",
UA_StatusCode_name(retval));
return retval;
}
static UA_StatusCode
register_server_with_discovery_server(UA_Server *server,
UA_Client *client,
const UA_Boolean isUnregister,
const char* semaphoreFilePath) {
/* Prepare the request. Do not cleanup the request after the service call,
* as the members are stack-allocated or point into the server config. */
UA_RegisterServer2Request request;
UA_RegisterServer2Request_init(&request);
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
request.server.isOnline = !isUnregister;
request.server.serverUri = server->config.applicationDescription.applicationUri;
request.server.productUri = server->config.applicationDescription.productUri;
request.server.serverType = server->config.applicationDescription.applicationType;
request.server.gatewayServerUri = server->config.applicationDescription.gatewayServerUri;
if(semaphoreFilePath) {
#ifdef UA_ENABLE_DISCOVERY_SEMAPHORE
request.server.semaphoreFilePath =
UA_STRING((char*)(uintptr_t)semaphoreFilePath); /* dirty cast */
#else
UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_CLIENT,
"Ignoring semaphore file path. open62541 not compiled "
"with UA_ENABLE_DISCOVERY_SEMAPHORE=ON");
#endif
}
request.server.serverNames = &server->config.applicationDescription.applicationName;
request.server.serverNamesSize = 1;
/* Copy the discovery urls from the server config and the network layers*/
size_t config_discurls = server->config.applicationDescription.discoveryUrlsSize;
size_t nl_discurls = server->config.networkLayersSize;
size_t total_discurls = config_discurls + nl_discurls;
UA_STACKARRAY(UA_String, urlsBuf, total_discurls);
request.server.discoveryUrls = urlsBuf;
request.server.discoveryUrlsSize = total_discurls;
for(size_t i = 0; i < config_discurls; ++i)
request.server.discoveryUrls[i] = server->config.applicationDescription.discoveryUrls[i];
/* TODO: Add nl only if discoveryUrl not already present */
for(size_t i = 0; i < nl_discurls; ++i) {
UA_ServerNetworkLayer *nl = &server->config.networkLayers[i];
request.server.discoveryUrls[config_discurls + i] = nl->discoveryUrl;
}
#ifdef UA_ENABLE_DISCOVERY_MULTICAST
request.discoveryConfigurationSize = 1;
request.discoveryConfiguration = UA_ExtensionObject_new();
UA_ExtensionObject_init(&request.discoveryConfiguration[0]);
// Set to NODELETE so that we can just use a pointer to the mdns config
request.discoveryConfiguration[0].encoding = UA_EXTENSIONOBJECT_DECODED_NODELETE;
request.discoveryConfiguration[0].content.decoded.type = &UA_TYPES[UA_TYPES_MDNSDISCOVERYCONFIGURATION];
request.discoveryConfiguration[0].content.decoded.data = &server->config.discovery.mdns;
#endif
// First try with RegisterServer2, if that isn't implemented, use RegisterServer
UA_RegisterServer2Response response;
__UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_REGISTERSERVER2REQUEST],
&response, &UA_TYPES[UA_TYPES_REGISTERSERVER2RESPONSE]);
UA_StatusCode serviceResult = response.responseHeader.serviceResult;
UA_RegisterServer2Response_deleteMembers(&response);
UA_Array_delete(request.discoveryConfiguration,
request.discoveryConfigurationSize,
&UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
request.discoveryConfiguration = NULL;
request.discoveryConfigurationSize = 0;
if(serviceResult == UA_STATUSCODE_BADNOTIMPLEMENTED ||
serviceResult == UA_STATUSCODE_BADSERVICEUNSUPPORTED) {
/* Try RegisterServer */
UA_RegisterServerRequest request_fallback;
UA_RegisterServerRequest_init(&request_fallback);
/* Copy from RegisterServer2 request */
request_fallback.requestHeader = request.requestHeader;
request_fallback.server = request.server;
UA_RegisterServerResponse response_fallback;
__UA_Client_Service(client, &request_fallback,
&UA_TYPES[UA_TYPES_REGISTERSERVERREQUEST],
&response_fallback,
&UA_TYPES[UA_TYPES_REGISTERSERVERRESPONSE]);
serviceResult = response_fallback.responseHeader.serviceResult;
UA_RegisterServerResponse_deleteMembers(&response_fallback);
}
if(serviceResult != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_CLIENT,
"RegisterServer/RegisterServer2 failed with statuscode %s",
UA_StatusCode_name(serviceResult));
}
return serviceResult;
}
END_TEST
START_TEST(Server_HistorizingStrategyUser)
{
// set a data backend
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = UA_HistoryDataBackend_Memory(3, 100);
setting.maxHistoryDataResponseSize = 100;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_USER;
UA_StatusCode retval = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// fill the data
UA_DateTime start = UA_DateTime_now();
UA_DateTime end = start + (10 * UA_DATETIME_SEC);
for (UA_UInt32 i = 0; i < 10; ++i) {
UA_DataValue value;
UA_DataValue_init(&value);
value.hasValue = true;
value.hasStatus = true;
value.status = UA_STATUSCODE_GOOD;
UA_Variant_setScalarCopy(&value.value, &i, &UA_TYPES[UA_TYPES_UINT32]);
value.hasSourceTimestamp = true;
value.sourceTimestamp = start + (i * UA_DATETIME_SEC);
value.hasServerTimestamp = true;
value.serverTimestamp = value.sourceTimestamp;
retval = setting.historizingBackend.serverSetHistoryData(server,
setting.historizingBackend.context,
NULL,
NULL,
&outNodeId,
UA_FALSE,
&value);
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
UA_DataValue_deleteMembers(&value);
}
// request
UA_HistoryReadResponse response;
UA_HistoryReadResponse_init(&response);
requestHistory(start, end, &response, 0, false, NULL);
// test the response
ck_assert_str_eq(UA_StatusCode_name(response.responseHeader.serviceResult), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(response.resultsSize, 1);
for (size_t i = 0; i < response.resultsSize; ++i) {
ck_assert_str_eq(UA_StatusCode_name(response.results[i].statusCode), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(response.results[i].historyData.encoding, UA_EXTENSIONOBJECT_DECODED);
ck_assert(response.results[i].historyData.content.decoded.type == &UA_TYPES[UA_TYPES_HISTORYDATA]);
UA_HistoryData * data = (UA_HistoryData *)response.results[i].historyData.content.decoded.data;
ck_assert_uint_eq(data->dataValuesSize, 10);
for (size_t j = 0; j < data->dataValuesSize; ++j) {
ck_assert_uint_eq(data->dataValues[j].hasSourceTimestamp, true);
ck_assert_uint_eq(data->dataValues[j].sourceTimestamp, start + (j * UA_DATETIME_SEC));
ck_assert_uint_eq(data->dataValues[j].hasStatus, true);
ck_assert_str_eq(UA_StatusCode_name(data->dataValues[j].status), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(data->dataValues[j].hasValue, true);
ck_assert(data->dataValues[j].value.type == &UA_TYPES[UA_TYPES_UINT32]);
UA_UInt32 * value = (UA_UInt32 *)data->dataValues[j].value.data;
ck_assert_uint_eq(*value, j);
}
}
UA_HistoryReadResponse_deleteMembers(&response);
UA_HistoryDataBackend_Memory_deleteMembers(&setting.historizingBackend);
}
int main(int argc, char **argv) {
signal(SIGINT, stopHandler); /* catches ctrl-c */
signal(SIGTERM, stopHandler);
UA_ServerConfig *config = UA_ServerConfig_new_minimal(16600, NULL);
// To enable mDNS discovery, set application type to discovery server.
config->applicationDescription.applicationType = UA_APPLICATIONTYPE_DISCOVERYSERVER;
UA_String_deleteMembers(&config->applicationDescription.applicationUri);
config->applicationDescription.applicationUri =
UA_String_fromChars("urn:open62541.example.server_multicast");
config->mdnsServerName = UA_String_fromChars("Sample Multicast Server");
// See http://www.opcfoundation.org/UA/schemas/1.03/ServerCapabilities.csv
//config.serverCapabilitiesSize = 1;
//UA_String caps = UA_String_fromChars("LDS");
//config.serverCapabilities = ∩︀
UA_Server *server = UA_Server_new(config);
self_discovery_url = &config->networkLayers[0].discoveryUrl;
/* add a variable node to the address space */
UA_Int32 myInteger = 42;
UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, "the answer");
UA_DataSource dateDataSource;
dateDataSource.read = readInteger;
dateDataSource.write = writeInteger;
UA_VariableAttributes attr = UA_VariableAttributes_default;
attr.description = UA_LOCALIZEDTEXT("en-US", "the answer");
attr.displayName = UA_LOCALIZEDTEXT("en-US", "the answer");
UA_Server_addDataSourceVariableNode(server, myIntegerNodeId,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
myIntegerName, UA_NODEID_NULL, attr, dateDataSource,
&myInteger, NULL);
// callback which is called when a new server is detected through mDNS
UA_Server_setServerOnNetworkCallback(server, serverOnNetworkCallback, NULL);
// Start the server and call iterate to wait for the multicast discovery of the LDS
UA_StatusCode retval = UA_Server_run_startup(server);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(logger, UA_LOGCATEGORY_SERVER,
"Could not start the server. StatusCode %s",
UA_StatusCode_name(retval));
UA_Server_delete(server);
UA_ServerConfig_delete(config);
UA_free(discovery_url);
return 1;
}
UA_LOG_INFO(logger, UA_LOGCATEGORY_SERVER,
"Server started. Waiting for announce of LDS Server.");
while (running && discovery_url == NULL)
UA_Server_run_iterate(server, true);
if(!running) {
UA_Server_delete(server);
UA_ServerConfig_delete(config);
UA_free(discovery_url);
return 1;
}
UA_LOG_INFO(logger, UA_LOGCATEGORY_SERVER, "LDS-ME server found on %s", discovery_url);
/* Check if the server supports sign and encrypt. OPC Foundation LDS requires an encrypted session for
* RegisterServer call, our server currently uses encrpytion optionally */
UA_EndpointDescription *endpointRegister = getRegisterEndpointFromServer(discovery_url);
UA_free(discovery_url);
if (endpointRegister == NULL || endpointRegister->securityMode == UA_MESSAGESECURITYMODE_INVALID) {
UA_LOG_ERROR(logger, UA_LOGCATEGORY_SERVER, "Could not find any suitable endpoints on discovery server");
UA_Server_delete(server);
UA_ServerConfig_delete(config);
return 1;
}
UA_Client *clientRegister = getRegisterClient(endpointRegister, argc, argv);
if (!clientRegister) {
UA_LOG_FATAL(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
"Could not create the client for remote registering");
UA_Server_delete(server);
UA_ServerConfig_delete(config);
return 1;
}
/* Connect the client */
char *endpointUrl = (char*)UA_malloc(endpointRegister->endpointUrl.length + 1);
memcpy(endpointUrl, endpointRegister->endpointUrl.data, endpointRegister->endpointUrl.length);
endpointUrl[endpointRegister->endpointUrl.length] = 0;
retval = UA_Server_addPeriodicServerRegisterCallback(server, clientRegister, endpointUrl,
10 * 60 * 1000, 500, NULL);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(logger, UA_LOGCATEGORY_SERVER,
"Could not create periodic job for server register. StatusCode %s",
UA_StatusCode_name(retval));
UA_free(endpointUrl);
UA_Client_disconnect(clientRegister);
UA_Client_delete(clientRegister);
UA_Server_delete(server);
UA_ServerConfig_delete(config);
return 1;
}
while (running)
UA_Server_run_iterate(server, true);
UA_Server_run_shutdown(server);
// UNregister the server from the discovery server.
retval = UA_Server_unregister_discovery(server, clientRegister);
if (retval != UA_STATUSCODE_GOOD)
UA_LOG_ERROR(logger, UA_LOGCATEGORY_SERVER,
"Could not unregister server from discovery server. "
"StatusCode %s", UA_StatusCode_name(retval));
UA_free(endpointUrl);
UA_Client_disconnect(clientRegister);
UA_Client_delete(clientRegister);
UA_Server_delete(server);
UA_ServerConfig_delete(config);
return (int)retval;
}
int main(void) {
/*
* Example for calling FindServersOnNetwork
*/
{
UA_ServerOnNetwork *serverOnNetwork = NULL;
size_t serverOnNetworkSize = 0;
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
UA_StatusCode retval = UA_Client_findServersOnNetwork(client, DISCOVERY_SERVER_ENDPOINT, 0, 0,
0, NULL, &serverOnNetworkSize, &serverOnNetwork);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER,
"Could not call FindServersOnNetwork service. "
"Is the discovery server started? StatusCode %s",
UA_StatusCode_name(retval));
UA_Client_delete(client);
return EXIT_FAILURE;
}
// output all the returned/registered servers
for(size_t i = 0; i < serverOnNetworkSize; i++) {
UA_ServerOnNetwork *server = &serverOnNetwork[i];
printf("Server[%lu]: %.*s", (unsigned long) i,
(int) server->serverName.length, server->serverName.data);
printf("\n\tRecordID: %d", server->recordId);
printf("\n\tDiscovery URL: %.*s", (int) server->discoveryUrl.length,
server->discoveryUrl.data);
printf("\n\tCapabilities: ");
for(size_t j = 0; j < server->serverCapabilitiesSize; j++) {
printf("%.*s,", (int) server->serverCapabilities[j].length,
server->serverCapabilities[j].data);
}
printf("\n\n");
}
UA_Array_delete(serverOnNetwork, serverOnNetworkSize,
&UA_TYPES[UA_TYPES_SERVERONNETWORK]);
}
/* Example for calling FindServers */
UA_ApplicationDescription *applicationDescriptionArray = NULL;
size_t applicationDescriptionArraySize = 0;
UA_StatusCode retval;
{
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
retval = UA_Client_findServers(client, DISCOVERY_SERVER_ENDPOINT, 0, NULL, 0, NULL,
&applicationDescriptionArraySize, &applicationDescriptionArray);
UA_Client_delete(client);
}
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "Could not call FindServers service. "
"Is the discovery server started? StatusCode %s", UA_StatusCode_name(retval));
return EXIT_FAILURE;
}
// output all the returned/registered servers
for(size_t i = 0; i < applicationDescriptionArraySize; i++) {
UA_ApplicationDescription *description = &applicationDescriptionArray[i];
printf("Server[%lu]: %.*s", (unsigned long) i, (int) description->applicationUri.length,
description->applicationUri.data);
printf("\n\tName: %.*s", (int) description->applicationName.text.length,
description->applicationName.text.data);
printf("\n\tApplication URI: %.*s", (int) description->applicationUri.length,
description->applicationUri.data);
printf("\n\tProduct URI: %.*s", (int) description->productUri.length,
description->productUri.data);
printf("\n\tType: ");
switch(description->applicationType) {
case UA_APPLICATIONTYPE_SERVER:
printf("Server");
break;
case UA_APPLICATIONTYPE_CLIENT:
printf("Client");
break;
case UA_APPLICATIONTYPE_CLIENTANDSERVER:
printf("Client and Server");
break;
case UA_APPLICATIONTYPE_DISCOVERYSERVER:
printf("Discovery Server");
break;
default:
printf("Unknown");
}
printf("\n\tDiscovery URLs:");
for(size_t j = 0; j < description->discoveryUrlsSize; j++) {
printf("\n\t\t[%lu]: %.*s", (unsigned long) j,
(int) description->discoveryUrls[j].length,
description->discoveryUrls[j].data);
}
printf("\n\n");
}
/*
* Now that we have the list of available servers, call get endpoints on all of them
*/
printf("-------- Server Endpoints --------\n");
for(size_t i = 0; i < applicationDescriptionArraySize; i++) {
UA_ApplicationDescription *description = &applicationDescriptionArray[i];
if(description->discoveryUrlsSize == 0) {
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_CLIENT,
"[GetEndpoints] Server %.*s did not provide any discovery urls. Skipping.",
(int)description->applicationUri.length, description->applicationUri.data);
continue;
}
printf("\nEndpoints for Server[%lu]: %.*s\n", (unsigned long) i,
(int) description->applicationUri.length, description->applicationUri.data);
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
char *discoveryUrl = (char *) UA_malloc(sizeof(char) * description->discoveryUrls[0].length + 1);
memcpy(discoveryUrl, description->discoveryUrls[0].data, description->discoveryUrls[0].length);
discoveryUrl[description->discoveryUrls[0].length] = '\0';
UA_EndpointDescription *endpointArray = NULL;
size_t endpointArraySize = 0;
//TODO: adapt to the new async getEndpoint
retval = UA_Client_getEndpoints(client, discoveryUrl, &endpointArraySize, &endpointArray);
UA_free(discoveryUrl);
if(retval != UA_STATUSCODE_GOOD) {
UA_Client_disconnect(client);
UA_Client_delete(client);
break;
}
for(size_t j = 0; j < endpointArraySize; j++) {
UA_EndpointDescription *endpoint = &endpointArray[j];
printf("\n\tEndpoint[%lu]:", (unsigned long) j);
printf("\n\t\tEndpoint URL: %.*s", (int) endpoint->endpointUrl.length, endpoint->endpointUrl.data);
printf("\n\t\tTransport profile URI: %.*s", (int) endpoint->transportProfileUri.length,
endpoint->transportProfileUri.data);
printf("\n\t\tSecurity Mode: ");
switch(endpoint->securityMode) {
case UA_MESSAGESECURITYMODE_INVALID:
printf("Invalid");
break;
case UA_MESSAGESECURITYMODE_NONE:
printf("None");
break;
case UA_MESSAGESECURITYMODE_SIGN:
printf("Sign");
break;
case UA_MESSAGESECURITYMODE_SIGNANDENCRYPT:
printf("Sign and Encrypt");
break;
default:
printf("No valid security mode");
break;
}
printf("\n\t\tSecurity profile URI: %.*s", (int) endpoint->securityPolicyUri.length,
endpoint->securityPolicyUri.data);
printf("\n\t\tSecurity Level: %d", endpoint->securityLevel);
}
UA_Array_delete(endpointArray, endpointArraySize, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
UA_Client_delete(client);
}
printf("\n");
UA_Array_delete(applicationDescriptionArray, applicationDescriptionArraySize,
&UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
return EXIT_SUCCESS;
}
